From 382e8a5c79cf21d6d0bf84e24d781d5f36a6b8ed Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 20 May 2025 15:58:14 +0200
Subject: [PATCH 1/7] Compiler: add BitSet.clear

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

diff --git a/compiler/lib/stdlib.ml b/compiler/lib/stdlib.ml
index 9ae41a24e1..bc2742ea93 100644
--- a/compiler/lib/stdlib.ml
+++ b/compiler/lib/stdlib.ml
@@ -879,6 +879,8 @@ module BitSet : sig
   val next_free : t -> int -> int
 
   val next_mem : t -> int -> int
+
+  val clear : t -> unit
 end = struct
   type t = { mutable arr : int array }
 
@@ -886,6 +888,8 @@ end = struct
 
   let create' n = { arr = Array.make ((n / Sys.int_size) + 1) 0 }
 
+  let clear t = Array.fill t.arr 0 (Array.length t.arr) 0
+
   let size t = Array.length t.arr * Sys.int_size
 
   let mem t i =

From b70234769ec7a447abf543a06bb46ff37fc91000 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 20 May 2025 13:02:36 +0200
Subject: [PATCH 2/7] Compiler: move return_values to Code

---
 compiler/lib/code.ml        | 24 ++++++++++++++++++++++++
 compiler/lib/code.mli       |  2 ++
 compiler/lib/global_flow.ml | 26 --------------------------
 3 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/compiler/lib/code.ml b/compiler/lib/code.ml
index eceb923f11..4399705188 100644
--- a/compiler/lib/code.ml
+++ b/compiler/lib/code.ml
@@ -845,6 +845,30 @@ let rec last_instr l =
   | [ i ] | [ i; Event _ ] -> Some i
   | _ :: rem -> last_instr rem
 
+(* Compute the list of variables containing the return values of each
+   function *)
+let return_values p =
+  fold_closures
+    p
+    (fun name_opt _ (pc, _) _ rets ->
+      match name_opt with
+      | None -> rets
+      | Some name ->
+          let s =
+            traverse
+              { fold = fold_children }
+              (fun pc s ->
+                let block = Addr.Map.find pc p.blocks in
+                match block.branch with
+                | Return x -> Var.Set.add x s
+                | _ -> s)
+              pc
+              p.blocks
+              Var.Set.empty
+          in
+          Var.Map.add name s rets)
+    Var.Map.empty
+
 let equal p1 p2 =
   p1.start = p2.start
   && Addr.Map.equal
diff --git a/compiler/lib/code.mli b/compiler/lib/code.mli
index c7b3696673..bc9dcab0e8 100644
--- a/compiler/lib/code.mli
+++ b/compiler/lib/code.mli
@@ -290,6 +290,8 @@ val fold_children_skip_try_body : 'c fold_blocs
 
 val poptraps : block Addr.Map.t -> Addr.t -> Addr.Set.t
 
+val return_values : program -> Var.Set.t Var.Map.t
+
 val traverse :
   fold_blocs_poly -> (Addr.t -> 'c -> 'c) -> Addr.t -> block Addr.Map.t -> 'c -> 'c
 
diff --git a/compiler/lib/global_flow.ml b/compiler/lib/global_flow.ml
index 1e167a47ef..4fe9d26420 100644
--- a/compiler/lib/global_flow.ml
+++ b/compiler/lib/global_flow.ml
@@ -45,32 +45,6 @@ let add_to_list h x v = Var.Hashtbl.replace h x (v :: associated_list h x)
 
 (****)
 
-(* Compute the list of variables containing the return values of each
-   function *)
-let return_values p =
-  Code.fold_closures
-    p
-    (fun name_opt _ (pc, _) _ rets ->
-      match name_opt with
-      | None -> rets
-      | Some name ->
-          let s =
-            Code.traverse
-              { fold = fold_children }
-              (fun pc s ->
-                let block = Addr.Map.find pc p.blocks in
-                match block.branch with
-                | Return x -> Var.Set.add x s
-                | _ -> s)
-              pc
-              p.blocks
-              Var.Set.empty
-          in
-          Var.Map.add name s rets)
-    Var.Map.empty
-
-(****)
-
 (* A variable is either let-bound, or a parameter, to which we
    associate a set of possible arguments.
 *)

From 79e62a4f951c60a0ac0d0ead8bb143aafda0e857 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 20 May 2025 15:54:11 +0200
Subject: [PATCH 3/7] Compiler: propagate arity across unit boundary -
 Propagate shape information through the flow analysis

---
 compiler/bin-js_of_ocaml/build_fs.ml       |   2 +-
 compiler/bin-js_of_ocaml/cmd_arg.ml        |  22 ++-
 compiler/bin-js_of_ocaml/cmd_arg.mli       |   2 +
 compiler/bin-js_of_ocaml/compile.ml        | 105 +++++++++----
 compiler/bin-wasm_of_ocaml/compile.ml      |   4 +-
 compiler/lib/config.ml                     |   2 +
 compiler/lib/config.mli                    |   2 +
 compiler/lib/driver.ml                     | 110 ++++++++++---
 compiler/lib/driver.mli                    |   8 +-
 compiler/lib/flow.ml                       | 101 +++++++++---
 compiler/lib/flow.mli                      |   7 +
 compiler/lib/ocaml_compiler.ml             |  40 +++++
 compiler/lib/ocaml_compiler.mli            |   7 +
 compiler/lib/parse_bytecode.ml             | 122 ++++++++++-----
 compiler/lib/pure_fun.ml                   |   7 +-
 compiler/lib/pure_fun.mli                  |   4 +
 compiler/lib/shape.ml                      | 174 +++++++++++++++++++++
 compiler/lib/shape.mli                     |  63 ++++++++
 compiler/tests-compiler/sourcemap.ml       |  52 +++---
 compiler/tests-full/dune                   |  37 +++++
 compiler/tests-full/m1.ml                  |   1 +
 compiler/tests-full/m2.ml                  |   1 +
 compiler/tests-full/m3.ml                  |   3 +
 compiler/tests-full/shapes.cma.expected.js |  86 ++++++++++
 compiler/tests-full/stdlib.cma.expected.js |  91 ++++++++++-
 25 files changed, 901 insertions(+), 152 deletions(-)
 create mode 100644 compiler/lib/shape.ml
 create mode 100644 compiler/lib/shape.mli
 create mode 100644 compiler/tests-full/m1.ml
 create mode 100644 compiler/tests-full/m2.ml
 create mode 100644 compiler/tests-full/m3.ml
 create mode 100644 compiler/tests-full/shapes.cma.expected.js

diff --git a/compiler/bin-js_of_ocaml/build_fs.ml b/compiler/bin-js_of_ocaml/build_fs.ml
index 27dfe0c97c..710b69ae72 100644
--- a/compiler/bin-js_of_ocaml/build_fs.ml
+++ b/compiler/bin-js_of_ocaml/build_fs.ml
@@ -75,7 +75,7 @@ function jsoo_create_file_extern(name,content){
   let code = Code.prepend Code.empty instr in
   Filename.gen_file output_file (fun chan ->
       let pfs_fmt = Pretty_print.to_out_channel chan in
-      let (_ : Source_map.info) =
+      let (_ : Source_map.info * Shape.t StringMap.t) =
         Driver.f
           ~standalone:true
           ~wrap_with_fun:`Iife
diff --git a/compiler/bin-js_of_ocaml/cmd_arg.ml b/compiler/bin-js_of_ocaml/cmd_arg.ml
index e6ccc53a4f..9cf9d61a4c 100644
--- a/compiler/bin-js_of_ocaml/cmd_arg.ml
+++ b/compiler/bin-js_of_ocaml/cmd_arg.ml
@@ -64,6 +64,8 @@ type t =
   ; static_env : (string * string) list
   ; wrap_with_fun : [ `Iife | `Named of string | `Anonymous ]
   ; target_env : Target_env.t
+  ; shape_files : string list
+  ; write_shape : bool
   ; (* toplevel *)
     dynlink : bool
   ; linkall : bool
@@ -114,6 +116,14 @@ let options =
     let doc = "Set output file name to [$(docv)]." in
     Arg.(value & opt (some string) None & info [ "o" ] ~docv:"FILE" ~doc)
   in
+  let shape_files =
+    let doc = "load shape file [$(docv)]." in
+    Arg.(value & opt_all string [] & info [ "load-shape" ] ~docv:"FILE" ~doc)
+  in
+  let write_shape =
+    let doc = "Emit shape files" in
+    Arg.(value & flag & info [ "write-shape" ] ~doc)
+  in
   let input_file =
     let doc =
       "Compile the bytecode program [$(docv)]. "
@@ -309,7 +319,9 @@ let options =
       input_file
       js_files
       keep_unit_names
-      effects =
+      effects
+      shape_files
+      write_shape =
     let inline_source_content = not sourcemap_don't_inline_content in
     let chop_extension s = try Filename.chop_extension s with Invalid_argument _ -> s in
     let runtime_files = js_files in
@@ -380,6 +392,8 @@ let options =
       ; source_map
       ; keep_unit_names
       ; effects
+      ; shape_files
+      ; write_shape
       }
   in
   let t =
@@ -412,7 +426,9 @@ let options =
       $ input_file
       $ js_files
       $ keep_unit_names
-      $ effects)
+      $ effects
+      $ shape_files
+      $ write_shape)
   in
   Term.ret t
 
@@ -633,6 +649,8 @@ let options_runtime_only =
       ; source_map
       ; keep_unit_names = false
       ; effects
+      ; shape_files = []
+      ; write_shape = false
       }
   in
   let t =
diff --git a/compiler/bin-js_of_ocaml/cmd_arg.mli b/compiler/bin-js_of_ocaml/cmd_arg.mli
index 331dc12b93..8be8344fb1 100644
--- a/compiler/bin-js_of_ocaml/cmd_arg.mli
+++ b/compiler/bin-js_of_ocaml/cmd_arg.mli
@@ -37,6 +37,8 @@ type t =
       | `Anonymous
       ]
   ; target_env : Target_env.t
+  ; shape_files : string list
+  ; write_shape : bool
   ; (* toplevel *)
     dynlink : bool
   ; linkall : bool
diff --git a/compiler/bin-js_of_ocaml/compile.ml b/compiler/bin-js_of_ocaml/compile.ml
index a64a1f53f2..357fced377 100644
--- a/compiler/bin-js_of_ocaml/compile.ml
+++ b/compiler/bin-js_of_ocaml/compile.ml
@@ -42,6 +42,7 @@ let source_map_enabled : Source_map.Encoding_spec.t option -> bool = function
   | Some _ -> true
 
 let output_gen
+    ~write_shape
     ~standalone
     ~custom_header
     ~build_info
@@ -53,7 +54,15 @@ let output_gen
     Driver.configure fmt;
     if standalone then header ~custom_header fmt;
     if Config.Flag.header () then jsoo_header fmt build_info;
-    let sm = f ~standalone ~source_map (k, fmt) in
+    let sm, shapes = f ~standalone ~shapes:write_shape ~source_map (k, fmt) in
+    (if write_shape
+     then
+       match output_file with
+       | `Stdout -> ()
+       | `Name name ->
+           Shape.Store.save'
+             (Filename.remove_extension name ^ Shape.Store.ext)
+             (StringMap.bindings shapes));
     match source_map, sm with
     | None, _ | _, None -> ()
     | Some { output_file = output; source_map; keep_empty }, Some sm ->
@@ -71,7 +80,6 @@ let output_gen
         Pretty_print.newline fmt;
         Pretty_print.string fmt (Printf.sprintf "//# sourceMappingURL=%s\n" urlData)
   in
-
   match output_file with
   | `Stdout -> f stdout `Stdout
   | `Name name -> Filename.gen_file name (fun chan -> f chan `File)
@@ -132,6 +140,11 @@ let sourcemap_of_infos ~base l =
 
 let sourcemap_of_info ~base info = sourcemap_of_infos ~base [ info ]
 
+let map_fst f (x, y) = f x, y
+
+let merge_shape a b =
+  StringMap.union (fun _name s1 s2 -> if Shape.equal s1 s2 then Some s1 else None) a b
+
 let run
     { Cmd_arg.common
     ; profile
@@ -156,6 +169,8 @@ let run
     ; keep_unit_names
     ; include_runtime
     ; effects
+    ; shape_files
+    ; write_shape
     } =
   let source_map_base =
     Option.map ~f:(fun spec -> spec.Source_map.Encoding_spec.source_map) source_map
@@ -172,6 +187,7 @@ let run
   | `Name _, _ -> ());
   List.iter params ~f:(fun (s, v) -> Config.Param.set s v);
   List.iter static_env ~f:(fun (s, v) -> Eval.set_static_env s v);
+  List.iter shape_files ~f:(fun fn -> Shape.Store.load' fn);
   let t = Timer.make () in
   let include_dirs =
     List.filter_map (include_dirs @ [ "+stdlib/" ]) ~f:(fun d -> Findlib.find [] d)
@@ -251,6 +267,7 @@ let run
       (one : Parse_bytecode.one)
       ~check_sourcemap
       ~standalone
+      ~shapes
       ~(source_map : Source_map.Encoding_spec.t option)
       ~link
       output_file =
@@ -269,6 +286,7 @@ let run
           let code = Code.prepend one.code instr in
           Driver.f
             ~standalone
+            ~shapes
             ?profile
             ~link
             ~wrap_with_fun
@@ -292,6 +310,7 @@ let run
           let res =
             Driver.f
               ~standalone
+              ~shapes
               ?profile
               ~link
               ~wrap_with_fun
@@ -313,6 +332,7 @@ let run
   let output_partial
       (cmo : Cmo_format.compilation_unit)
       ~standalone
+      ~shapes
       ~source_map
       code
       ((_, fmt) as output_file) =
@@ -320,7 +340,14 @@ let run
     let uinfo = Unit_info.of_cmo cmo in
     Pretty_print.string fmt "\n";
     Pretty_print.string fmt (Unit_info.to_string uinfo);
-    output code ~check_sourcemap:true ~source_map ~standalone ~link:`No output_file
+    output
+      code
+      ~check_sourcemap:true
+      ~source_map
+      ~standalone
+      ~shapes
+      ~link:`No
+      output_file
   in
   let output_partial_runtime ~standalone ~source_map ((_, fmt) as output_file) =
     assert (not standalone);
@@ -371,12 +398,13 @@ let run
         { code; cmis = StringSet.empty; debug = Parse_bytecode.Debug.default_summary }
       in
       output_gen
+        ~write_shape
         ~standalone:true
         ~custom_header
         ~build_info:(Build_info.create `Runtime)
         ~source_map
         (fst output_file)
-        (fun ~standalone ~source_map ((_, fmt) as output_file) ->
+        (fun ~standalone ~shapes ~source_map ((_, fmt) as output_file) ->
           Pretty_print.string fmt "\n";
           Pretty_print.string fmt (Unit_info.to_string uinfo);
           output
@@ -384,9 +412,10 @@ let run
             ~check_sourcemap:false
             ~source_map
             ~standalone
+            ~shapes
             ~link:`All
             output_file
-          |> sourcemap_of_info ~base:source_map_base)
+          |> map_fst (sourcemap_of_info ~base:source_map_base))
   | (`Stdin | `File _) as bytecode ->
       let kind, ic, close_ic, include_dirs =
         match bytecode with
@@ -419,20 +448,22 @@ let run
           in
           if times () then Format.eprintf "  parsing: %a@." Timer.print t1;
           output_gen
+            ~write_shape
             ~standalone:true
             ~custom_header
             ~build_info:(Build_info.create `Exe)
             ~source_map
             (fst output_file)
-            (fun ~standalone ~source_map output_file ->
+            (fun ~standalone ~shapes ~source_map output_file ->
               output
                 code
                 ~check_sourcemap:true
                 ~standalone
+                ~shapes
                 ~source_map
                 ~link:(if linkall then `All else `Needed)
                 output_file
-              |> sourcemap_of_info ~base:source_map_base)
+              |> map_fst (sourcemap_of_info ~base:source_map_base))
       | `Cmo cmo ->
           let output_file =
             match output_file, keep_unit_names with
@@ -457,20 +488,26 @@ let run
           in
           if times () then Format.eprintf "  parsing: %a@." Timer.print t1;
           output_gen
+            ~write_shape
             ~standalone:false
             ~custom_header
             ~build_info:(Build_info.create `Cmo)
             ~source_map
             output_file
-            (fun ~standalone ~source_map output ->
+            (fun ~standalone ~shapes ~source_map output ->
               match include_runtime with
               | true ->
-                  let sm1 = output_partial_runtime ~standalone ~source_map output in
-                  let sm2 = output_partial cmo code ~standalone ~source_map output in
-                  sourcemap_of_infos ~base:source_map_base [ sm1; sm2 ]
+                  let sm1, sh1 =
+                    output_partial_runtime ~standalone ~shapes ~source_map output
+                  in
+                  let sm2, sh2 =
+                    output_partial cmo code ~standalone ~shapes ~source_map output
+                  in
+                  ( sourcemap_of_infos ~base:source_map_base [ sm1; sm2 ]
+                  , merge_shape sh1 sh2 )
               | false ->
-                  output_partial cmo code ~standalone ~source_map output
-                  |> sourcemap_of_info ~base:source_map_base)
+                  output_partial cmo code ~standalone ~shapes ~source_map output
+                  |> map_fst (sourcemap_of_info ~base:source_map_base))
       | `Cma cma when keep_unit_names ->
           (if include_runtime
            then
@@ -486,14 +523,15 @@ let run
                    failwith "use [-o dirname/] or remove [--keep-unit-names]"
              in
              output_gen
+               ~write_shape
                ~standalone:false
                ~custom_header
                ~build_info:(Build_info.create `Runtime)
                ~source_map
                (`Name output_file)
-               (fun ~standalone ~source_map output ->
-                 output_partial_runtime ~standalone ~source_map output
-                 |> sourcemap_of_info ~base:source_map_base));
+               (fun ~standalone ~shapes ~source_map output ->
+                 output_partial_runtime ~standalone ~shapes ~source_map output
+                 |> map_fst (sourcemap_of_info ~base:source_map_base)));
           List.iter cma.lib_units ~f:(fun cmo ->
               let output_file =
                 match output_file with
@@ -522,23 +560,26 @@ let run
                   t1
                   (Ocaml_compiler.Cmo_format.name cmo);
               output_gen
+                ~write_shape
                 ~standalone:false
                 ~custom_header
                 ~build_info:(Build_info.create `Cma)
                 ~source_map
                 (`Name output_file)
-                (fun ~standalone ~source_map output ->
-                  output_partial ~standalone ~source_map cmo code output
-                  |> sourcemap_of_info ~base:source_map_base))
+                (fun ~standalone ~shapes ~source_map output ->
+                  output_partial ~standalone ~shapes ~source_map cmo code output
+                  |> map_fst (sourcemap_of_info ~base:source_map_base)))
       | `Cma cma ->
-          let f ~standalone ~source_map output =
-            let source_map_runtime =
+          let f ~standalone ~shapes ~source_map output =
+            (* Always compute shapes because it can be used by other units of the cma *)
+            let shapes = shapes || true in
+            let runtime =
               if not include_runtime
               then None
-              else Some (output_partial_runtime ~standalone ~source_map output)
+              else Some (output_partial_runtime ~standalone ~shapes ~source_map output)
             in
 
-            let source_map_units =
+            let units =
               List.map cma.lib_units ~f:(fun cmo ->
                   let t1 = Timer.make () in
                   let code =
@@ -556,16 +597,22 @@ let run
                       Timer.print
                       t1
                       (Ocaml_compiler.Cmo_format.name cmo);
-                  output_partial ~standalone ~source_map cmo code output)
+                  output_partial ~standalone ~shapes ~source_map cmo code output)
+            in
+            let sm_and_shapes =
+              match runtime with
+              | None -> units
+              | Some x -> x :: units
             in
-            let sm =
-              match source_map_runtime with
-              | None -> source_map_units
-              | Some x -> x :: source_map_units
+            let shapes =
+              List.fold_left sm_and_shapes ~init:StringMap.empty ~f:(fun acc (_, s) ->
+                  merge_shape s acc)
             in
-            sourcemap_of_infos ~base:source_map_base sm
+            ( sourcemap_of_infos ~base:source_map_base (List.map sm_and_shapes ~f:fst)
+            , shapes )
           in
           output_gen
+            ~write_shape
             ~standalone:false
             ~custom_header
             ~build_info:(Build_info.create `Cma)
diff --git a/compiler/bin-wasm_of_ocaml/compile.ml b/compiler/bin-wasm_of_ocaml/compile.ml
index cab61f022e..31b5efb88c 100644
--- a/compiler/bin-wasm_of_ocaml/compile.ml
+++ b/compiler/bin-wasm_of_ocaml/compile.ml
@@ -245,7 +245,7 @@ let generate_prelude ~out_file =
   let code, uinfo = Parse_bytecode.predefined_exceptions () in
   let profile = Profile.O1 in
   let Driver.{ program; variable_uses; in_cps; deadcode_sentinal; _ } =
-    Driver.optimize ~profile code
+    Driver.optimize ~profile ~shapes:false code
   in
   let context = Generate.start () in
   let _ =
@@ -397,7 +397,7 @@ let run
     let code = one.code in
     let standalone = Option.is_none unit_name in
     let Driver.{ program; variable_uses; in_cps; deadcode_sentinal; _ } =
-      Driver.optimize ~profile code
+      Driver.optimize ~profile ~shapes:false code
     in
     let context = Generate.start () in
     let toplevel_name, generated_js =
diff --git a/compiler/lib/config.ml b/compiler/lib/config.ml
index db97d62450..c5cab8ffe7 100644
--- a/compiler/lib/config.ml
+++ b/compiler/lib/config.ml
@@ -106,6 +106,8 @@ module Flag = struct
   let auto_link = o ~name:"auto-link" ~default:true
 
   let es6 = o ~name:"es6" ~default:false
+
+  let load_shapes_auto = o ~name:"load-shapes-auto" ~default:false
 end
 
 module Param = struct
diff --git a/compiler/lib/config.mli b/compiler/lib/config.mli
index 71642430bf..09c8b6ab1a 100644
--- a/compiler/lib/config.mli
+++ b/compiler/lib/config.mli
@@ -76,6 +76,8 @@ module Flag : sig
 
   val es6 : unit -> bool
 
+  val load_shapes_auto : unit -> bool
+
   val enable : string -> unit
 
   val disable : string -> unit
diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index c4e2367676..62f678118b 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -23,12 +23,15 @@ let debug = Debug.find "main"
 
 let times = Debug.find "times"
 
+let debug_shapes = Debug.find "shapes"
+
 type optimized_result =
   { program : Code.program
   ; variable_uses : Deadcode.variable_uses
   ; trampolined_calls : Effects.trampolined_calls
   ; in_cps : Effects.in_cps
   ; deadcode_sentinal : Code.Var.t
+  ; shapes : Shape.t StringMap.t
   }
 
 let should_export = function
@@ -90,9 +93,51 @@ let phi p =
 
 let ( +> ) f g x = g (f x)
 
-let map_fst f (x, y, z) = f x, y, z
+let map_fst4 f (x, y, z, t) = f x, y, z, t
+
+
+let collects_shapes ~shapes (p : Code.program) =
+  if debug_shapes () || shapes
+  then (
+    let t = Timer.make () in
+    let shapes = ref StringMap.empty in
+    Code.Addr.Map.iter
+      (fun _ block ->
+        List.iter block.Code.body ~f:(fun i ->
+            match i with
+            | Code.Let
+                ( _
+                , Prim
+                    ( Extern "caml_register_global"
+                    , [ _code; Pv block; Pc (NativeString name) ] ) ) ->
+                let name =
+                  match name with
+                  | Byte s -> s
+                  | Utf (Utf8 s) -> s
+                in
+                shapes := StringMap.add name block !shapes
+            | _ -> ()))
+      p.blocks;
+    let map =
+      if StringMap.is_empty !shapes
+      then StringMap.empty
+      else
+        let _, info = Flow.f p in
+        let pure = Pure_fun.f p in
+        let return_values = Code.return_values p in
+        StringMap.filter_map
+          (fun _ x ->
+            match Flow.the_shape_of ~return_values ~pure info x with
+            | Top -> None
+            | (Function _ | Block _) as s -> Some s)
+          !shapes
+    in
+    if times () then Format.eprintf "  shapes: %a@." Timer.print t;
+    map)
+  else StringMap.empty
+
 
-let effects_and_exact_calls ~deadcode_sentinal (profile : Profile.t) p =
+let effects_and_exact_calls ~deadcode_sentinal ~shapes (profile : Profile.t) p =
   let fast =
     match Config.effects (), profile with
     | (`Cps | `Double_translation), _ -> false
@@ -109,19 +154,21 @@ let effects_and_exact_calls ~deadcode_sentinal (profile : Profile.t) p =
   in
   match Config.effects () with
   | `Cps | `Double_translation ->
-      if debug () then Format.eprintf "Effects...@.";
-      Effects.f ~flow_info:info ~live_vars p
-      |> map_fst
-           (match Config.target () with
-           | `Wasm -> Fun.id
-           | `JavaScript -> Lambda_lifting.f)
+     if debug () then Format.eprintf "Effects...@.";
+     let shapes = collects_shapes ~shapes p in
+     let p, tramp, cps = Effects.f ~flow_info:info ~live_vars p in
+     let p = match Config.target () with
+           | `Wasm -> p
+           | `JavaScript -> Lambda_lifting.f p in
+     p, tramp, cps, shapes
   | `Disabled | `Jspi ->
       let p =
         Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
       in
+      let shapes = collects_shapes ~shapes p in
       ( p
       , (Code.Var.Set.empty : Effects.trampolined_calls)
-      , (Code.Var.Set.empty : Effects.in_cps) )
+      , (Code.Var.Set.empty : Effects.in_cps), shapes )
 
 let print p =
   if debug () then Code.Print.program Format.err_formatter (fun _ _ -> "") p;
@@ -168,7 +215,7 @@ let generate
     ~exported_runtime
     ~wrap_with_fun
     ~warn_on_unhandled_effect
-    { program; variable_uses; trampolined_calls; deadcode_sentinal; in_cps } =
+    { program; variable_uses; trampolined_calls; deadcode_sentinal; in_cps; shapes = _ } =
   if times () then Format.eprintf "Start Generation...@.";
   let should_export = should_export wrap_with_fun in
   Generate.f
@@ -594,6 +641,7 @@ let simplify_js js =
   if times () then Format.eprintf "  optimizing: %a@." Timer.print t;
   js
 
+
 let configure formatter =
   let pretty = Config.Flag.pretty () in
   Pretty_print.set_compact formatter (not pretty)
@@ -609,7 +657,7 @@ let link_and_pack ?(standalone = true) ?(wrap_with_fun = `Iife) ?(link = `No) p
   |> pack ~wrap_with_fun ~standalone
   |> check_js
 
-let optimize ~profile p =
+let optimize ~shapes ~profile p =
   let deadcode_sentinal =
     (* If deadcode is disabled, this field is just fresh variable *)
     Code.Var.fresh_n "dummy"
@@ -622,22 +670,22 @@ let optimize ~profile p =
        | O2 -> o2
        | O3 -> o3)
     +> specialize_js_once_after
-    +> effects_and_exact_calls ~deadcode_sentinal profile
-    +> map_fst
+    +> effects_and_exact_calls ~deadcode_sentinal ~shapes profile 
+    +> map_fst4
          (match Config.target (), Config.effects () with
          | `JavaScript, `Disabled -> Generate_closure.f
          | `JavaScript, (`Cps | `Double_translation) | `Wasm, (`Jspi | `Cps) -> Fun.id
          | `JavaScript, `Jspi | `Wasm, (`Disabled | `Double_translation) -> assert false)
-    +> map_fst deadcode'
+    +> map_fst4 deadcode'
   in
   if times () then Format.eprintf "Start Optimizing...@.";
   let t = Timer.make () in
-  let (program, variable_uses), trampolined_calls, in_cps = opt p in
+  let (program, variable_uses), trampolined_calls, in_cps, shapes = opt p in
   let () = if times () then Format.eprintf " optimizations : %a@." Timer.print t in
-  { program; variable_uses; trampolined_calls; in_cps; deadcode_sentinal }
+  { program; variable_uses; trampolined_calls; in_cps; deadcode_sentinal; shapes }
 
-let full ~standalone ~wrap_with_fun ~profile ~link ~source_map ~formatter p =
-  let optimized_code = optimize ~profile p in
+let full ~shapes ~standalone ~wrap_with_fun ~profile ~link ~source_map ~formatter p =
+  let optimized_code = optimize ~profile ~shapes p in
   let exported_runtime = not standalone in
   let emit formatter =
     generate ~exported_runtime ~wrap_with_fun ~warn_on_unhandled_effect:standalone
@@ -646,11 +694,21 @@ let full ~standalone ~wrap_with_fun ~profile ~link ~source_map ~formatter p =
     +> name_variables
     +> output formatter ~source_map ()
   in
-  emit formatter optimized_code
-
-let full_no_source_map ~formatter ~standalone ~wrap_with_fun ~profile ~link p =
-  let (_ : Source_map.info) =
-    full ~standalone ~wrap_with_fun ~profile ~link ~source_map:false ~formatter p
+  let shapes = optimized_code.shapes in
+  StringMap.iter
+    (fun name shape ->
+      Shape.Store.set ~name shape;
+      if debug_shapes ()
+      then
+        Pretty_print.string
+          formatter
+          (Printf.sprintf "//# shape: %s:%s\n" name (Shape.to_string shape)))
+    shapes;
+  emit formatter optimized_code, shapes
+
+let full_no_source_map ~formatter ~shapes ~standalone ~wrap_with_fun ~profile ~link p =
+  let (_ : Source_map.info * _) =
+    full ~shapes ~standalone ~wrap_with_fun ~profile ~link ~source_map:false ~formatter p
   in
   ()
 
@@ -658,11 +716,12 @@ let f
     ?(standalone = true)
     ?(wrap_with_fun = `Iife)
     ?(profile = Profile.O1)
+    ?(shapes = false)
     ~link
     ~source_map
     ~formatter
     p =
-  full ~standalone ~wrap_with_fun ~profile ~link ~source_map ~formatter p
+  full ~standalone ~wrap_with_fun ~shapes ~profile ~link ~source_map ~formatter p
 
 let f'
     ?(standalone = true)
@@ -671,12 +730,13 @@ let f'
     ~link
     formatter
     p =
-  full_no_source_map ~formatter ~standalone ~wrap_with_fun ~profile ~link p
+  full_no_source_map ~formatter ~shapes:false ~standalone ~wrap_with_fun ~profile ~link p
 
 let from_string ~prims ~debug s formatter =
   let p = Parse_bytecode.from_string ~prims ~debug s in
   full_no_source_map
     ~formatter
+    ~shapes:false
     ~standalone:false
     ~wrap_with_fun:`Anonymous
     ~profile:O1
diff --git a/compiler/lib/driver.mli b/compiler/lib/driver.mli
index 7c274322be..82596f10ea 100644
--- a/compiler/lib/driver.mli
+++ b/compiler/lib/driver.mli
@@ -18,25 +18,29 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *)
 
+open Stdlib
+
 type optimized_result =
   { program : Code.program
   ; variable_uses : Deadcode.variable_uses
   ; trampolined_calls : Effects.trampolined_calls
   ; in_cps : Effects.in_cps
   ; deadcode_sentinal : Code.Var.t
+  ; shapes : Shape.t StringMap.t
   }
 
-val optimize : profile:Profile.t -> Code.program -> optimized_result
+val optimize : shapes:bool -> profile:Profile.t -> Code.program -> optimized_result
 
 val f :
      ?standalone:bool
   -> ?wrap_with_fun:[ `Iife | `Anonymous | `Named of string ]
   -> ?profile:Profile.t
+  -> ?shapes:bool
   -> link:[ `All | `All_from of string list | `Needed | `No ]
   -> source_map:bool
   -> formatter:Pretty_print.t
   -> Code.program
-  -> Source_map.info
+  -> Source_map.info * Shape.t StringMap.t
 
 val f' :
      ?standalone:bool
diff --git a/compiler/lib/flow.ml b/compiler/lib/flow.ml
index adf814ec9e..e96b6c835d 100644
--- a/compiler/lib/flow.ml
+++ b/compiler/lib/flow.ml
@@ -156,15 +156,18 @@ let propagate1 deps defs st x =
       | Constant _ | Apply _ | Prim _ | Special _ | Closure _ | Block _ ->
           Var.Set.singleton x
       | Field (y, n, _) ->
-          var_set_lift
-            (fun z ->
-              match defs.(Var.idx z) with
-              | Expr (Block (_, a, _, _)) when n < Array.length a ->
-                  let t = a.(n) in
-                  add_dep deps x t;
-                  Var.Tbl.get st t
-              | Phi _ | Param | Expr _ -> Var.Set.empty)
-            (Var.Tbl.get st y))
+          if Shape.State.mem x
+          then Var.Set.singleton x
+          else
+            var_set_lift
+              (fun z ->
+                match defs.(Var.idx z) with
+                | Expr (Block (_, a, _, _)) when n < Array.length a ->
+                    let t = a.(n) in
+                    add_dep deps x t;
+                    Var.Tbl.get st t
+                | Phi _ | Param | Expr _ -> Var.Set.empty)
+              (Var.Tbl.get st y))
 
 module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl)
 
@@ -301,16 +304,17 @@ let propagate2 defs known_origins possibly_mutable st x =
       match e with
       | Constant _ | Closure _ | Apply _ | Prim _ | Block _ | Special _ -> false
       | Field (y, n, _) ->
-          Var.Tbl.get st y
-          || Var.Set.exists
-               (fun z ->
-                 match defs.(Var.idx z) with
-                 | Expr (Block (_, a, _, _)) ->
-                     n >= Array.length a
-                     || Var.ISet.mem possibly_mutable z
-                     || Var.Tbl.get st a.(n)
-                 | Phi _ | Param | Expr _ -> true)
-               (Var.Tbl.get known_origins y))
+          (not (Shape.State.mem x))
+          && (Var.Tbl.get st y
+             || Var.Set.exists
+                  (fun z ->
+                    match defs.(Var.idx z) with
+                    | Expr (Block (_, a, _, _)) ->
+                        n >= Array.length a
+                        || Var.ISet.mem possibly_mutable z
+                        || Var.Tbl.get st a.(n)
+                    | Phi _ | Param | Expr _ -> true)
+                  (Var.Tbl.get known_origins y)))
 
 module Domain2 = struct
   type t = bool
@@ -458,6 +462,65 @@ let direct_approx (info : Info.t) x =
         y
   | _ -> None
 
+let the_shape_of ~return_values ~pure info x =
+  let rec loop info x acc : Shape.t =
+    if Var.Set.mem x acc
+    then Top
+    else
+      get_approx
+        info
+        (fun x ->
+          match Shape.State.get x with
+          | Some shape -> shape
+          | None -> (
+              match info.info_defs.(Var.idx x) with
+              | Expr (Block (_, a, _, Immutable)) ->
+                  Shape.Block (List.map ~f:(fun x -> loop info x acc) (Array.to_list a))
+              | Expr (Closure (l, _, _)) ->
+                  let pure = Pure_fun.pure pure x in
+                  let res =
+                    match Var.Map.find x return_values with
+                    | exception Not_found -> Shape.Top
+                    | set ->
+                        let set = Var.Set.remove x set in
+                        if Var.Set.is_empty set
+                        then Shape.Top
+                        else
+                          let first = Var.Set.choose set in
+                          Var.Set.fold
+                            (fun x s1 ->
+                              let s2 = loop info x acc in
+                              Shape.merge s1 s2)
+                            set
+                            (loop info first acc)
+                  in
+                  Shape.Function { arity = List.length l; pure; res }
+              | Expr (Special (Alias_prim name)) -> (
+                  try
+                    let arity = Primitive.arity name in
+                    let pure = Primitive.is_pure name in
+                    Shape.Function { arity; pure; res = Top }
+                  with _ -> Top)
+              | Expr (Apply { f; args; _ }) ->
+                  let shape = loop info f (Var.Set.add f acc) in
+                  let rec loop n' shape =
+                    match shape with
+                    | Shape.Function { arity = n; pure; res } ->
+                        if n = n'
+                        then res
+                        else if n' < n
+                        then Shape.Function { arity = n - n'; pure; res }
+                        else loop (n' - n) res
+                    | Shape.Block _ | Shape.Top -> Shape.Top
+                  in
+                  loop (List.length args) shape
+              | _ -> Shape.Top))
+        Top
+        (fun u v -> Shape.merge u v)
+        x
+  in
+  loop info x Var.Set.empty
+
 let build_subst (info : Info.t) vars =
   let nv = Var.count () in
   let subst = Array.init nv ~f:(fun i -> Var.of_idx i) in
diff --git a/compiler/lib/flow.mli b/compiler/lib/flow.mli
index d7c49f621e..58b4e1afb0 100644
--- a/compiler/lib/flow.mli
+++ b/compiler/lib/flow.mli
@@ -67,3 +67,10 @@ val the_block_contents_of : Info.t -> Code.prim_arg -> Code.Var.t array option
 val the_int : Info.t -> Code.prim_arg -> Targetint.t option
 
 val f : Code.program -> Code.program * Info.t
+
+val the_shape_of :
+     return_values:Code.Var.Set.t Code.Var.Map.t
+  -> pure:Pure_fun.t
+  -> Info.t
+  -> Code.Var.t
+  -> Shape.t
diff --git a/compiler/lib/ocaml_compiler.ml b/compiler/lib/ocaml_compiler.ml
index 00d35a06b3..0c4ed37a34 100644
--- a/compiler/lib/ocaml_compiler.ml
+++ b/compiler/lib/ocaml_compiler.ml
@@ -37,6 +37,46 @@ let rec constant_of_const c : Code.constant =
       let l = Array.of_list (List.map l ~f:constant_of_const) in
       Tuple (tag, l, Unknown)
 
+type module_or_not =
+  | Module
+  | Not_module
+  | Unknown
+
+let rec is_module_in_summary deep ident' summary =
+  match summary with
+  (* Unknown *)
+  | Env.Env_empty -> deep, Unknown
+  (* Module *)
+  | Env.Env_module (summary, ident, _, _)
+  | Env.Env_functor_arg (summary, ident)
+  | Env.Env_persistent (summary, ident) ->
+      if Ident.same ident ident'
+      then deep, Module
+      else is_module_in_summary (deep + 1) ident' summary
+  (* Not_module *)
+  | Env.Env_modtype (summary, ident, _) | Env.Env_extension (summary, ident, _) ->
+      if Ident.same ident ident'
+      then deep, Not_module
+      else is_module_in_summary (deep + 1) ident' summary
+  (* Lowercase ident *)
+  | Env.Env_value (summary, ident, _)
+  | Env.Env_type (summary, ident, _)
+  | Env.Env_class (summary, ident, _)
+  | Env.Env_cltype (summary, ident, _) ->
+      ignore (ident : Ident.t);
+      is_module_in_summary (deep + 1) ident' summary
+  (* Other, no ident *)
+  | Env.Env_open (summary, _)
+  | Env.Env_constraints (summary, _)
+  | Env.Env_copy_types summary
+  | Env.Env_value_unbound (summary, _, _)
+  | Env.Env_module_unbound (summary, _, _) ->
+      is_module_in_summary (deep + 1) ident' summary
+
+let is_module_in_summary ident summary =
+  let _deep, b = is_module_in_summary 0 ident summary in
+  b
+
 module Symtable = struct
   (* Copied from ocaml/bytecomp/symtable.ml *)
   module Num_tbl (M : Map.S) = struct
diff --git a/compiler/lib/ocaml_compiler.mli b/compiler/lib/ocaml_compiler.mli
index afcb137b29..0c4c31dd8a 100644
--- a/compiler/lib/ocaml_compiler.mli
+++ b/compiler/lib/ocaml_compiler.mli
@@ -18,6 +18,13 @@
 
 val constant_of_const : Lambda.structured_constant -> Code.constant
 
+type module_or_not =
+  | Module
+  | Not_module
+  | Unknown
+
+val is_module_in_summary : Ident.t -> Env.summary -> module_or_not
+
 module Symtable : sig
   module Global : sig
     type t =
diff --git a/compiler/lib/parse_bytecode.ml b/compiler/lib/parse_bytecode.ml
index 0ce79a4f6e..16f396db8f 100644
--- a/compiler/lib/parse_bytecode.ml
+++ b/compiler/lib/parse_bytecode.ml
@@ -583,6 +583,9 @@ module State = struct
     ; env_offset : int
     ; handlers : handler list
     ; globals : globals
+    ; immutable : unit Code.Var.Hashtbl.t
+    ; module_or_not : Ocaml_compiler.module_or_not Ident.Tbl.t
+    ; includes : string list
     }
 
   let fresh_var state =
@@ -667,8 +670,17 @@ module State = struct
 
   let pop_handler state = { state with handlers = List.tl state.handlers }
 
-  let initial g =
-    { accu = Unset; stack = []; env = [||]; env_offset = 0; handlers = []; globals = g }
+  let initial includes g immutable =
+    { accu = Unset
+    ; stack = []
+    ; env = [||]
+    ; env_offset = 0
+    ; handlers = []
+    ; globals = g
+    ; immutable
+    ; module_or_not = Ident.Tbl.create 0
+    ; includes
+    }
 
   let rec print_stack f l =
     match l with
@@ -691,20 +703,37 @@ module State = struct
       print_env
       st.env
 
-  let rec name_rec debug i l s summary =
+  let maybe_module ident =
+    match (Ident.name ident).[0] with
+    | 'A' .. 'Z' -> true
+    | _ -> false
+
+  let rec name_rec debug st i l s summary =
     match l, s with
     | [], _ -> ()
     | (j, ident) :: lrem, Var v :: srem when i = j ->
+        (if maybe_module ident && not (Code.Var.Hashtbl.mem st.immutable v)
+         then
+           match Ident.Tbl.find st.module_or_not ident with
+           | Module -> Code.Var.Hashtbl.add st.immutable v ()
+           | Not_module -> ()
+           | (exception Not_found) | Unknown -> (
+               match Ocaml_compiler.is_module_in_summary ident summary with
+               | Module ->
+                   Ident.Tbl.add st.module_or_not ident Module;
+                   Code.Var.Hashtbl.add st.immutable v ()
+               | Not_module -> Ident.Tbl.add st.module_or_not ident Not_module
+               | Unknown -> ()));
         Var.set_name v (Ident.name ident);
-        name_rec debug (i + 1) lrem srem summary
-    | (j, _) :: _, _ :: srem when i < j -> name_rec debug (i + 1) l srem summary
+        name_rec debug st (i + 1) lrem srem summary
+    | (j, _) :: _, _ :: srem when i < j -> name_rec debug st (i + 1) l srem summary
     | _ -> assert false
 
   let name_vars st debug pc =
     if Debug.names debug
     then
       let l, summary = Debug.find debug pc in
-      name_rec debug 0 l st.stack summary
+      name_rec debug st 0 l st.stack summary
 
   let rec make_stack i state =
     if i = 0
@@ -797,6 +826,12 @@ let get_global state instrs i =
             let x, state = State.fresh_var state in
             if debug_parser () then Format.printf "%a = CONST(%d)@." Var.print x i;
             g.vars.(i) <- Some x;
+            (match g.named_value.(i) with
+            | None -> ()
+            | Some name -> (
+                match Shape.Store.load ~name ~paths:state.includes with
+                | None -> ()
+                | Some shape -> Shape.State.assign x shape));
             x, state, instrs
         | false, `Wasm -> (
             (* Reference to another compilation units in case of separate
@@ -850,6 +885,8 @@ let string_of_addr debug_data addr =
       in
       Printf.sprintf "%s:%s-%s %s" file (pos loc.loc_start) (pos loc.loc_end) kind)
 
+let is_immutable _instr _infos _pc = (* We don't know yet *) Maybe_mutable
+
 let rec compile_block blocks joins debug_data code pc state : unit =
   match Addr.Map.find_opt pc !tagged_blocks with
   | Some old_state -> (
@@ -1355,6 +1392,7 @@ and compile infos pc state (instrs : instr list) =
         let j = getu code (pc + 2) in
         let y, state = State.fresh_var state in
         if debug_parser () then Format.printf "%a = %a[%d]@." Var.print y Var.print x j;
+        Shape.State.propagate x j y;
         compile infos (pc + 3) state (Let (y, Field (x, j, Non_float)) :: instrs)
     | PUSHGETGLOBALFIELD ->
         let state = State.push state in
@@ -1364,6 +1402,7 @@ and compile infos pc state (instrs : instr list) =
         let j = getu code (pc + 2) in
         let y, state = State.fresh_var state in
         if debug_parser () then Format.printf "%a = %a[%d]@." Var.print y Var.print x j;
+        Shape.State.propagate x j y;
         compile infos (pc + 3) state (Let (y, Field (x, j, Non_float)) :: instrs)
     | SETGLOBAL ->
         let i = getu code (pc + 1) in
@@ -1377,47 +1416,36 @@ and compile infos pc state (instrs : instr list) =
         let x, state = State.fresh_var state in
         if debug_parser () then Format.printf "%a = 0@." Var.print x;
         let instrs = register_global g i instrs in
+        Code.Var.Hashtbl.add state.immutable (access_global g i) ();
         compile infos (pc + 2) state (Let (x, const 0) :: instrs)
     | ATOM0 ->
         let x, state = State.fresh_var state in
 
         if debug_parser () then Format.printf "%a = ATOM(0)@." Var.print x;
-        compile
-          infos
-          (pc + 1)
-          state
-          (Let (x, Block (0, [||], Unknown, Maybe_mutable)) :: instrs)
+        let imm = is_immutable instr infos pc in
+        compile infos (pc + 1) state (Let (x, Block (0, [||], Unknown, imm)) :: instrs)
     | ATOM ->
         let i = getu code (pc + 1) in
         let x, state = State.fresh_var state in
 
         if debug_parser () then Format.printf "%a = ATOM(%d)@." Var.print x i;
-        compile
-          infos
-          (pc + 2)
-          state
-          (Let (x, Block (i, [||], Unknown, Maybe_mutable)) :: instrs)
+        let imm = is_immutable instr infos pc in
+        compile infos (pc + 2) state (Let (x, Block (i, [||], Unknown, imm)) :: instrs)
     | PUSHATOM0 ->
         let state = State.push state in
         let x, state = State.fresh_var state in
 
         if debug_parser () then Format.printf "%a = ATOM(0)@." Var.print x;
-        compile
-          infos
-          (pc + 1)
-          state
-          (Let (x, Block (0, [||], Unknown, Maybe_mutable)) :: instrs)
+        let imm = is_immutable instr infos pc in
+        compile infos (pc + 1) state (Let (x, Block (0, [||], Unknown, imm)) :: instrs)
     | PUSHATOM ->
         let state = State.push state in
 
         let i = getu code (pc + 1) in
         let x, state = State.fresh_var state in
         if debug_parser () then Format.printf "%a = ATOM(%d)@." Var.print x i;
-        compile
-          infos
-          (pc + 2)
-          state
-          (Let (x, Block (i, [||], Unknown, Maybe_mutable)) :: instrs)
+        let imm = is_immutable instr infos pc in
+        compile infos (pc + 2) state (Let (x, Block (i, [||], Unknown, imm)) :: instrs)
     | MAKEBLOCK ->
         let size = getu code (pc + 1) in
         let tag = getu code (pc + 2) in
@@ -1432,22 +1460,24 @@ and compile infos pc state (instrs : instr list) =
             Format.printf "%d = %a; " i Var.print (List.nth contents i)
           done;
           Format.printf "}@.");
+        let imm = is_immutable instr infos pc in
         compile
           infos
           (pc + 3)
           state
-          (Let (x, Block (tag, Array.of_list contents, Unknown, Maybe_mutable)) :: instrs)
+          (Let (x, Block (tag, Array.of_list contents, Unknown, imm)) :: instrs)
     | MAKEBLOCK1 ->
         let tag = getu code (pc + 1) in
         let y = State.accu state in
         let x, state = State.fresh_var state in
 
         if debug_parser () then Format.printf "%a = { 0 = %a; }@." Var.print x Var.print y;
+        let imm = is_immutable instr infos pc in
         compile
           infos
           (pc + 2)
           state
-          (Let (x, Block (tag, [| y |], Unknown, Maybe_mutable)) :: instrs)
+          (Let (x, Block (tag, [| y |], Unknown, imm)) :: instrs)
     | MAKEBLOCK2 ->
         let tag = getu code (pc + 1) in
         let y = State.accu state in
@@ -1457,11 +1487,12 @@ and compile infos pc state (instrs : instr list) =
         if debug_parser ()
         then
           Format.printf "%a = { 0 = %a; 1 = %a; }@." Var.print x Var.print y Var.print z;
+        let imm = is_immutable instr infos pc in
         compile
           infos
           (pc + 2)
           (State.pop 1 state)
-          (Let (x, Block (tag, [| y; z |], Unknown, Maybe_mutable)) :: instrs)
+          (Let (x, Block (tag, [| y; z |], Unknown, imm)) :: instrs)
     | MAKEBLOCK3 ->
         let tag = getu code (pc + 1) in
         let y = State.accu state in
@@ -1481,11 +1512,12 @@ and compile infos pc state (instrs : instr list) =
             z
             Var.print
             t;
+        let imm = is_immutable instr infos pc in
         compile
           infos
           (pc + 2)
           (State.pop 2 state)
-          (Let (x, Block (tag, [| y; z; t |], Unknown, Maybe_mutable)) :: instrs)
+          (Let (x, Block (tag, [| y; z; t |], Unknown, imm)) :: instrs)
     | MAKEFLOATBLOCK ->
         let size = getu code (pc + 1) in
         let state = State.push state in
@@ -1499,34 +1531,39 @@ and compile infos pc state (instrs : instr list) =
             Format.printf "%d = %a; " i Var.print (List.nth contents i)
           done;
           Format.printf "}@.");
+        let imm = is_immutable instr infos pc in
         compile
           infos
           (pc + 2)
           state
-          (Let (x, Block (254, Array.of_list contents, Unknown, Maybe_mutable)) :: instrs)
+          (Let (x, Block (254, Array.of_list contents, Unknown, imm)) :: instrs)
     | GETFIELD0 ->
         let y = State.accu state in
         let x, state = State.fresh_var state in
 
         if debug_parser () then Format.printf "%a = %a[0]@." Var.print x Var.print y;
+        Shape.State.propagate y 0 x;
         compile infos (pc + 1) state (Let (x, Field (y, 0, Non_float)) :: instrs)
     | GETFIELD1 ->
         let y = State.accu state in
         let x, state = State.fresh_var state in
 
         if debug_parser () then Format.printf "%a = %a[1]@." Var.print x Var.print y;
+        Shape.State.propagate y 1 x;
         compile infos (pc + 1) state (Let (x, Field (y, 1, Non_float)) :: instrs)
     | GETFIELD2 ->
         let y = State.accu state in
         let x, state = State.fresh_var state in
 
         if debug_parser () then Format.printf "%a = %a[2]@." Var.print x Var.print y;
+        Shape.State.propagate y 2 x;
         compile infos (pc + 1) state (Let (x, Field (y, 2, Non_float)) :: instrs)
     | GETFIELD3 ->
         let y = State.accu state in
         let x, state = State.fresh_var state in
 
         if debug_parser () then Format.printf "%a = %a[3]@." Var.print x Var.print y;
+        Shape.State.propagate y 3 x;
         compile infos (pc + 1) state (Let (x, Field (y, 3, Non_float)) :: instrs)
     | GETFIELD ->
         let y = State.accu state in
@@ -1534,6 +1571,7 @@ and compile infos pc state (instrs : instr list) =
         let x, state = State.fresh_var state in
 
         if debug_parser () then Format.printf "%a = %a[%d]@." Var.print x Var.print y n;
+        Shape.State.propagate y n x;
         compile infos (pc + 2) state (Let (x, Field (y, n, Non_float)) :: instrs)
     | GETFLOATFIELD ->
         let y = State.accu state in
@@ -2510,18 +2548,28 @@ type one =
   ; debug : Debug.summary
   }
 
-let parse_bytecode code globals debug_data =
-  let state = State.initial globals in
+let parse_bytecode ~includes code globals debug_data =
+  let immutable = Code.Var.Hashtbl.create 0 in
+  let state = State.initial includes globals immutable in
   Code.Var.reset ();
   let blocks', joins = Blocks.analyse code in
+  Shape.State.reset ();
   let p =
     if not (Blocks.is_empty blocks')
     then (
       let start = 0 in
+
       compile_block blocks' joins debug_data code start state;
       let blocks =
         Addr.Map.mapi
           (fun _ (state, instr, last) ->
+            let instr =
+              List.map instr ~f:(function
+                | Let (x, Block (tag, args, k, Maybe_mutable))
+                  when Code.Var.Hashtbl.mem immutable x ->
+                    Let (x, Block (tag, args, k, Immutable))
+                | x -> x)
+            in
             { params =
                 (match state with
                 | Some state -> State.stack_vars state
@@ -2682,7 +2730,7 @@ let from_exe
     Ocaml_compiler.Symtable.GlobalMap.iter symbols ~f:(fun id n ->
         globals.named_value.(n) <- Some (Ocaml_compiler.Symtable.Global.name id);
         globals.is_exported.(n) <- true);
-  let p = parse_bytecode code globals debug_data in
+  let p = parse_bytecode ~includes code globals debug_data in
   (* register predefined exception *)
   let body =
     List.fold_left predefined_exceptions ~init:[] ~f:(fun body (i, name) ->
@@ -2812,7 +2860,7 @@ let from_bytes ~prims ~debug (code : bytecode) =
     t
   in
   let globals = make_globals 0 [||] prims in
-  let p = parse_bytecode code globals debug_data in
+  let p = parse_bytecode ~includes:[] code globals debug_data in
   let gdata = Var.fresh_n "global_data" in
   let need_gdata = ref false in
   let find_name i =
@@ -2944,7 +2992,7 @@ module Reloc = struct
     globals
 end
 
-let from_compilation_units ~includes:_ ~include_cmis ~debug_data l =
+let from_compilation_units ~includes ~include_cmis ~debug_data l =
   let reloc = Reloc.create () in
   List.iter l ~f:(fun (compunit, code) -> Reloc.step1 reloc compunit code);
   List.iter l ~f:(fun (compunit, code) -> Reloc.step2 reloc compunit code);
@@ -2953,7 +3001,7 @@ let from_compilation_units ~includes:_ ~include_cmis ~debug_data l =
     let l = List.map l ~f:(fun (_, c) -> Bytes.to_string c) in
     String.concat ~sep:"" l
   in
-  let prog = parse_bytecode code globals debug_data in
+  let prog = parse_bytecode ~includes code globals debug_data in
   let gdata = Var.fresh_n "global_data" in
   let need_gdata = ref false in
   let body =
diff --git a/compiler/lib/pure_fun.ml b/compiler/lib/pure_fun.ml
index da4a9c59aa..153cfc157e 100644
--- a/compiler/lib/pure_fun.ml
+++ b/compiler/lib/pure_fun.ml
@@ -27,11 +27,16 @@ open Code
 
 (****)
 
+let pure pure_funs x = Var.Set.mem x pure_funs
+
+let empty = Var.Set.empty
+
 let pure_expr pure_funs e =
   match e with
   | Block _ | Field _ | Closure _ | Constant _ -> true
   | Special (Alias_prim _) -> true
-  | Apply { f; exact; _ } -> exact && Var.Set.mem f pure_funs
+  | Apply { f; exact; _ } ->
+      exact && (Var.Set.mem f pure_funs || Shape.State.is_pure_fun f)
   | Prim (p, _l) -> (
       match p with
       | Extern f -> Primitive.is_pure f
diff --git a/compiler/lib/pure_fun.mli b/compiler/lib/pure_fun.mli
index f0adbf272c..7d373c9fe9 100644
--- a/compiler/lib/pure_fun.mli
+++ b/compiler/lib/pure_fun.mli
@@ -24,4 +24,8 @@ val pure_expr : t -> Code.expr -> bool
 
 val pure_instr : t -> Code.instr -> bool
 
+val pure : t -> Code.Var.t -> bool
+
+val empty : t
+
 val f : Code.program -> t
diff --git a/compiler/lib/shape.ml b/compiler/lib/shape.ml
new file mode 100644
index 0000000000..764a1571e0
--- /dev/null
+++ b/compiler/lib/shape.ml
@@ -0,0 +1,174 @@
+(* Js_of_ocaml compiler
+ * http://www.ocsigen.org/js_of_ocaml/
+ * Copyright (C) 2024 Hugo Heuzard
+ *
+ * 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! Stdlib
+
+type t =
+  | Top
+  | Block of t list
+  | Function of
+      { arity : int
+      ; pure : bool
+      ; res : t
+      }
+
+type shape = t
+
+let rec equal a b =
+  match a, b with
+  | Top, Top -> true
+  | ( Function { arity = a1; pure = p1; res = r1 }
+    , Function { arity = a2; pure = p2; res = r2 } ) ->
+      a1 = a2 && Bool.(p1 = p2) && equal r1 r2
+  | Block b1, Block b2 -> (
+      try List.for_all2 ~f:equal b1 b2 with Invalid_argument _ -> false)
+  | Top, (Function _ | Block _) | Function _, (Top | Block _) | Block _, (Top | Function _)
+    -> false
+
+let rec merge (u : t) (v : t) =
+  match u, v with
+  | ( Function { arity = a1; pure = p1; res = r1 }
+    , Function { arity = a2; pure = p2; res = r2 } ) ->
+      if a1 = a2 then Function { arity = a1; pure = p1 && p2; res = merge r1 r2 } else Top
+  | Block b1, Block b2 ->
+      if List.length b1 = List.length b2 then Block (List.map2 b1 b2 ~f:merge) else Top
+  | Top, _ | _, Top -> Top
+  | Function _, Block _ | Block _, Function _ -> Top
+
+let rec to_string (shape : t) =
+  match shape with
+  | Top -> "N"
+  | Block l -> "[" ^ String.concat ~sep:"," (List.map ~f:to_string l) ^ "]"
+  | Function { arity; pure; res } ->
+      Printf.sprintf
+        "F(%d)%s%s"
+        arity
+        (if pure then "*" else "")
+        (match res with
+        | Top -> ""
+        | _ -> "->" ^ to_string res)
+
+module Store = struct
+  let ext = ".jsoo-shape"
+
+  let filename ~dir ~name = Filename.concat dir (name ^ ext)
+
+  let t = String.Hashtbl.create 17
+
+  let loaded = String.Hashtbl.create 17
+
+  let set ~name shape = String.Hashtbl.replace t name shape
+
+  let get ~name = String.Hashtbl.find_opt t name
+
+  let magic = "JsooShape000"
+
+  let load' fn =
+    let ic = open_in_bin fn in
+    let m = really_input_string ic (String.length magic) in
+    if not (String.equal m magic)
+    then failwith (Printf.sprintf "Invalid magic number for shape file %s" fn);
+    let shapes : (string * shape) list = Marshal.from_channel ic in
+    close_in ic;
+    List.iter shapes ~f:(fun (name, shape) -> set ~name shape)
+
+  let load ~name ~paths =
+    if String.Hashtbl.mem t name
+    then get ~name
+    else if not (Config.Flag.load_shapes_auto ())
+    then None
+    else
+      match Fs.find_in_path paths (filename ~dir:"." ~name) with
+      | Some f ->
+          load' f;
+          get ~name
+      | None ->
+          let rec scan : _ -> shape option = function
+            | [] -> None
+            | dir :: xs -> (
+                let l =
+                  Sys.readdir dir
+                  |> Array.to_list
+                  |> List.sort ~cmp:String.compare
+                  |> List.map ~f:(fun n -> Filename.concat dir n)
+                in
+                match
+                  List.find_map l ~f:(fun s ->
+                      if Filename.check_suffix s ext && not (String.Hashtbl.mem loaded s)
+                      then (
+                        load' s;
+                        String.Hashtbl.add loaded s ();
+                        match get ~name with
+                        | None -> None
+                        | Some shape -> Some (s, shape))
+                      else None)
+                with
+                | None -> scan xs
+                | Some (fn, shape) ->
+                    Format.eprintf "Shape: %s loaded from %s\n" name fn;
+                    Some shape)
+          in
+          scan paths
+
+  let save' fn (l : (string * shape) list) =
+    let oc = open_out_bin fn in
+    output_string oc magic;
+    Marshal.to_channel oc l [];
+    close_out oc
+
+  let save ~name ~dir =
+    match get ~name with
+    | None -> failwith (Printf.sprintf "Don't know any shape for %s" name)
+    | Some shape ->
+        let fn = filename ~dir ~name in
+        save' fn [ name, shape ]
+end
+
+module State = struct
+  type nonrec t =
+    { table : t Code.Var.Hashtbl.t
+    ; cache : BitSet.t
+    }
+
+  let t : t = { table = Code.Var.Hashtbl.create 17; cache = BitSet.create () }
+
+  let assign x shape =
+    Code.Var.Hashtbl.replace t.table x shape;
+    BitSet.set t.cache (Code.Var.idx x)
+
+  let propagate x offset target =
+    match Code.Var.Hashtbl.find_opt t.table x with
+    | None -> ()
+    | Some (Top | Function _) -> ()
+    | Some (Block l) -> assign target (List.nth l offset)
+
+  let mem x = BitSet.mem t.cache (Code.Var.idx x)
+
+  let get x = if mem x then Code.Var.Hashtbl.find_opt t.table x else None
+
+  let is_pure_fun x =
+    match Code.Var.Hashtbl.find_opt t.table x with
+    | None -> false
+    | Some (Top | Block _) -> false
+    | Some (Function { pure; _ }) -> pure
+
+  let reset () =
+    Code.Var.Hashtbl.clear t.table;
+    BitSet.clear t.cache
+end
diff --git a/compiler/lib/shape.mli b/compiler/lib/shape.mli
new file mode 100644
index 0000000000..180840f9d6
--- /dev/null
+++ b/compiler/lib/shape.mli
@@ -0,0 +1,63 @@
+(* Js_of_ocaml compiler
+ * http://www.ocsigen.org/js_of_ocaml/
+ * Copyright (C) 2024 Hugo Heuzard
+ *
+ * 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.
+ *)
+
+type t =
+  | Top
+  | Block of t list
+  | Function of
+      { arity : int
+      ; pure : bool
+      ; res : t
+      }
+
+val to_string : t -> string
+
+val equal : t -> t -> bool
+
+val merge : t -> t -> t
+
+module Store : sig
+  val ext : string
+
+  val set : name:string -> t -> unit
+
+  val get : name:string -> t option
+
+  val load' : string -> unit
+
+  val load : name:string -> paths:string list -> t option
+
+  val save : name:string -> dir:string -> unit
+
+  val save' : string -> (string * t) list -> unit
+end
+
+module State : sig
+  val propagate : Code.Var.t -> int -> Code.Var.t -> unit
+
+  val assign : Code.Var.t -> t -> unit
+
+  val get : Code.Var.t -> t option
+
+  val mem : Code.Var.t -> bool
+
+  val is_pure_fun : Code.Var.t -> bool
+
+  val reset : unit -> unit
+end
diff --git a/compiler/tests-compiler/sourcemap.ml b/compiler/tests-compiler/sourcemap.ml
index ad83ae7cc8..661911190f 100644
--- a/compiler/tests-compiler/sourcemap.ml
+++ b/compiler/tests-compiler/sourcemap.ml
@@ -67,32 +67,32 @@ let%expect_test _ =
               -> print_mapping ~line_offset:gen_line ~col_offset:gen_column map));
   [%expect
     {|
-      $ cat "test.ml"
-        1: let id x = x
-      $ cat "test.js"
-        1:
-        2: //# unitInfo: Provides: Test
-        3: (function(globalThis){
-        4:    "use strict";
-        5:    var runtime = globalThis.jsoo_runtime;
-        6:    function id(x){return x;}
-        7:    var Test = [0, id];
-        8:    runtime.caml_register_global(0, Test, "Test");
-        9:    return;
-       10:   }
-       11:   (globalThis));
-       12:
-       13: //# sourceMappingURL=test.map
-      /builtin/blackbox.ml:1:0 -> 5:7
-      /builtin/blackbox.ml:1:0 -> 5:17
-      /builtin/blackbox.ml:1:0 -> 6:0
-      /builtin/blackbox.ml:1:0 -> 6:12
-      /builtin/blackbox.ml:1:0 -> 6:15
-      /dune-root/test.ml:1:11 -> 6:18
-      /dune-root/test.ml:1:12 -> 6:27
-      /dune-root/test.ml:1:12 -> 7:0
-      /dune-root/test.ml:1:12 -> 7:7
-      /builtin/blackbox.ml:1:0 -> 7:14
+    $ cat "test.ml"
+      1: let id x = x
+    $ cat "test.js"
+      1:
+      2: //# unitInfo: Provides: Test
+      3: (function(globalThis){
+      4:    "use strict";
+      5:    var runtime = globalThis.jsoo_runtime;
+      6:    function id(x){return x;}
+      7:    var Test = [0, id];
+      8:    runtime.caml_register_global(0, Test, "Test");
+      9:    return;
+     10:   }
+     11:   (globalThis));
+     12:
+     13: //# sourceMappingURL=test.map
+    /builtin/blackbox.ml:1:0 -> 5:7
+    /builtin/blackbox.ml:1:0 -> 5:17
+    /builtin/blackbox.ml:1:0 -> 6:0
+    /builtin/blackbox.ml:1:0 -> 6:12
+    /builtin/blackbox.ml:1:0 -> 6:15
+    /dune-root/test.ml:1:11 -> 6:18
+    /dune-root/test.ml:1:12 -> 6:27
+    /dune-root/test.ml:1:12 -> 7:0
+    /dune-root/test.ml:1:12 -> 7:7
+    /builtin/blackbox.ml:1:0 -> 7:14
     |}]
 
 let%expect_test _ =
diff --git a/compiler/tests-full/dune b/compiler/tests-full/dune
index f4fef6cd83..67c542571f 100644
--- a/compiler/tests-full/dune
+++ b/compiler/tests-full/dune
@@ -11,6 +11,8 @@
    --debug
    var
    --debuginfo
+   --debug
+   shapes
    %{lib:stdlib:stdlib.cma}
    -o
    %{targets})))
@@ -35,6 +37,41 @@
  (action
   (diff stdlib.cma.expected.js stdlib.cma.output.js)))
 
+(library
+ (name shapes)
+ (modules m1 m2 m3))
+
+(rule
+ (targets shapes.cma.js)
+ (enabled_if
+  (= %{ocaml_version} "5.2.0"))
+ (action
+  (run
+   %{bin:js_of_ocaml}
+   --pretty
+   --debuginfo
+   --debug
+   shapes
+   %{dep:shapes.cma}
+   -o
+   %{targets})))
+
+(rule
+ (targets shapes.cma.output.js)
+ (enabled_if
+  (= %{ocaml_version} "5.2.0"))
+ (action
+  (with-stdout-to
+   %{targets}
+   (run tail -n +3 %{dep:shapes.cma.js}))))
+
+(rule
+ (alias runtest)
+ (enabled_if
+  (= %{ocaml_version} "5.2.0"))
+ (action
+  (diff shapes.cma.expected.js shapes.cma.output.js)))
+
 (rule
  (targets fs.output.js)
  (deps file1 file2)
diff --git a/compiler/tests-full/m1.ml b/compiler/tests-full/m1.ml
new file mode 100644
index 0000000000..0a01e76687
--- /dev/null
+++ b/compiler/tests-full/m1.ml
@@ -0,0 +1 @@
+let f () () = ()
diff --git a/compiler/tests-full/m2.ml b/compiler/tests-full/m2.ml
new file mode 100644
index 0000000000..46cfe56e5e
--- /dev/null
+++ b/compiler/tests-full/m2.ml
@@ -0,0 +1 @@
+let f () = print_endline ""
diff --git a/compiler/tests-full/m3.ml b/compiler/tests-full/m3.ml
new file mode 100644
index 0000000000..196093fbd7
--- /dev/null
+++ b/compiler/tests-full/m3.ml
@@ -0,0 +1,3 @@
+let f () = if Random.int 2 > 1 then M1.f else fun () () -> M2.f ()
+
+let x = f () () ()
diff --git a/compiler/tests-full/shapes.cma.expected.js b/compiler/tests-full/shapes.cma.expected.js
new file mode 100644
index 0000000000..8aabd47fe3
--- /dev/null
+++ b/compiler/tests-full/shapes.cma.expected.js
@@ -0,0 +1,86 @@
+
+//# unitInfo: Provides: Shapes
+//# shape: Shapes:[]
+(function
+  (globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime, Shapes = [0];
+   runtime.caml_register_global(0, Shapes, "Shapes");
+   return;
+  }
+  (globalThis));
+
+//# unitInfo: Provides: Shapes__M1
+//# shape: Shapes__M1:[F(2)*]
+(function
+  (globalThis){
+   "use strict";
+   var runtime = globalThis.jsoo_runtime;
+   function f(_a_, param){
+     /*<<compiler/tests-full/m1.ml:1:14>>*/ return 0;
+    /*<<compiler/tests-full/m1.ml:1:16>>*/ }
+   var Shapes_M1 =  /*<<?>>*/ [0, f];
+   runtime.caml_register_global(0, Shapes_M1, "Shapes__M1");
+   return;
+  }
+  (globalThis));
+
+//# unitInfo: Provides: Shapes__M2
+//# unitInfo: Requires: Stdlib
+//# shape: Shapes__M2:[F(1)]
+(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
+    global_data = runtime.caml_get_global_data(),
+    cst = "",
+    Stdlib = global_data.Stdlib;
+   function f(param){
+     /*<<compiler/tests-full/m2.ml:1:11>>*/ return caml_call1(Stdlib[46], cst) /*<<compiler/tests-full/m2.ml:1:27>>*/ ;
+   }
+   var Shapes_M2 =  /*<<?>>*/ [0, f];
+   runtime.caml_register_global(2, Shapes_M2, "Shapes__M2");
+   return;
+  }
+  (globalThis));
+
+//# unitInfo: Provides: Shapes__M3
+//# unitInfo: Requires: Shapes__M1, Shapes__M2, Stdlib__Random
+//# shape: Shapes__M3:[F(1)->F(2),N]
+(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
+    global_data = runtime.caml_get_global_data(),
+    Shapes_M2 = global_data.Shapes__M2,
+    Stdlib_Random = global_data.Stdlib__Random,
+    Shapes_M1 = global_data.Shapes__M1;
+   function f(param){
+     /*<<compiler/tests-full/m3.ml:1:14>>*/ return 1
+            < caml_call1(Stdlib_Random[5], 2)
+            ? Shapes_M1[1]
+            : function
+             (_a_, param){
+               /*<<compiler/tests-full/m3.ml:1:59>>*/ return Shapes_M2[1].call
+                      (null, 0) /*<<compiler/tests-full/m3.ml:1:66>>*/ ;
+             };
+   }
+   var
+    x =  /*<<compiler/tests-full/m3.ml:4:8>>*/ f(0)(0, 0),
+    Shapes_M3 =  /*<<compiler/tests-full/m3.ml:4:18>>*/ [0, f, x];
+   runtime.caml_register_global(3, Shapes_M3, "Shapes__M3");
+   return;
+   /*<<?>>*/ }
+  (globalThis));
diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js
index 9f79a6046e..e4194dfd2d 100644
--- a/compiler/tests-full/stdlib.cma.expected.js
+++ b/compiler/tests-full/stdlib.cma.expected.js
@@ -1,5 +1,6 @@
 
 //# unitInfo: Provides: CamlinternalFormatBasics
+//# shape: CamlinternalFormatBasics:[F(2),F(1),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -349,6 +350,7 @@
 
 //# unitInfo: Provides: Stdlib
 //# unitInfo: Requires: CamlinternalFormatBasics
+//# shape: Stdlib:[F(1),F(1),N,N,N,N,N,N,N,N,N,N,N,N,N,F(2)*,F(2)*,F(1)*,N,N,F(1)*,N,N,N,N,N,N,F(2)*,F(1),F(1)*,F(1)*,F(1),F(1)*,F(1),F(1),F(1),F(2),N,N,N,F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(3),F(1),F(1),F(2),F(2),F(2),F(4),F(4),F(2),F(2),F(2),F(2),F(1),F(1),F(1),F(1),F(2),F(1),F(1),F(3),F(1),F(1),F(4),F(4),F(2),F(1),F(1),F(1),F(2),F(1),F(1),F(1),F(1),F(2),N,F(1)*,F(2),F(1),F(1),F(1),F(4),F(1),N]
 (function
   (globalThis){
    "use strict";
@@ -979,7 +981,9 @@
   (globalThis));
 
 //# unitInfo: Provides: Stdlib__Either
-(function(globalThis){
+//# shape: Stdlib__Either:[F(1)*,F(1)*,F(1)*,F(1)*,F(1)*,F(1)*,F(2),F(2),F(3),F(3),F(3),F(3),F(4),F(4)]
+(function
+  (globalThis){
    "use strict";
    var runtime = globalThis.jsoo_runtime;
    function caml_call1(f, a0){
@@ -1095,6 +1099,7 @@
 
 //# unitInfo: Provides: Stdlib__Sys
 //# unitInfo: Requires: Stdlib
+//# shape: Stdlib__Sys:[N,F(1),N,N,[N],N,N,N,N,N,N,N,N,N,F(2)*,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,F(1)*,N,N,N,F(1),F(1),[F(2)*]]
 (function
   (globalThis){
    "use strict";
@@ -1202,6 +1207,7 @@
 
 //# unitInfo: Provides: Stdlib__Obj
 //# unitInfo: Requires: Stdlib, Stdlib__Sys
+//# shape: Stdlib__Obj:[F(1)*,F(2),F(3),N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,[F(1),F(1)*,F(1)*],N]
 (function
   (globalThis){
    "use strict";
@@ -1379,6 +1385,7 @@
 
 //# unitInfo: Provides: Stdlib__Type
 //# unitInfo: Requires: Stdlib__Obj
+//# shape: Stdlib__Type:[[F(1)*,F(1),F(2)*]]
 (function
   (globalThis){
    "use strict";
@@ -1411,7 +1418,9 @@
   (globalThis));
 
 //# unitInfo: Provides: Stdlib__Atomic
-(function(globalThis){
+//# shape: Stdlib__Atomic:[F(1)*,F(1),F(1),F(2),F(2),F(3),F(2),F(1),F(1)]
+(function
+  (globalThis){
    "use strict";
    var
     runtime = globalThis.jsoo_runtime,
@@ -1448,6 +1457,7 @@
 
 //# unitInfo: Provides: CamlinternalLazy
 //# unitInfo: Requires: Stdlib, Stdlib__Obj
+//# shape: CamlinternalLazy:[N,F(1),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -1524,6 +1534,7 @@
 
 //# unitInfo: Provides: Stdlib__Lazy
 //# unitInfo: Requires: CamlinternalLazy, Stdlib, Stdlib__Obj
+//# shape: Stdlib__Lazy:[N,F(2)*,F(1),F(1),F(2),F(1),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -1619,6 +1630,7 @@
 
 //# unitInfo: Provides: Stdlib__Seq
 //# unitInfo: Requires: CamlinternalLazy, Stdlib, Stdlib__Atomic, Stdlib__Lazy
+//# shape: Stdlib__Seq:[F(1),F(1),F(1),F(2),F(3),F(2),F(3),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(4),F(3),F(3),F(3),F(3),F(1)*,F(2)*,F(3)*,F(2),F(3),F(2)*,F(2),F(2),F(2)*->F(1)*,F(3),F(2)*->F(1),F(3),F(3),F(3)*->F(1)*,F(2),F(2),F(3),F(3),F(3),F(1)->F(1),N,F(1)->F(1),F(2),F(3),F(2),F(3),F(3),F(3),F(4),F(3),F(4),F(2)*,F(3)*->F(1),F(1)*,F(1)*,F(2)*,F(2)*,F(1)*->F(1),F(1)*->F(1),F(2)*]
 (function
   (globalThis){
    "use strict";
@@ -2544,6 +2556,7 @@
 
 //# unitInfo: Provides: Stdlib__Option
 //# unitInfo: Requires: Stdlib, Stdlib__Seq
+//# shape: Stdlib__Option:[N,F(1)*,F(2)*,F(1),F(2),F(1)*,F(2),F(3),F(2),F(1)*,F(1)*,F(3),F(3),F(2)*,F(1)*,F(1)]
 (function
   (globalThis){
    "use strict";
@@ -2669,6 +2682,7 @@
 
 //# unitInfo: Provides: Stdlib__Result
 //# unitInfo: Requires: Stdlib, Stdlib__Seq
+//# shape: Stdlib__Result:[F(1)*,F(1)*,F(2)*,F(1),F(1),F(2),F(1)*,F(2),F(2),F(3),F(2),F(2),F(1)*,F(1)*,F(4),F(4),F(1)*,F(1)*,F(1)]
 (function
   (globalThis){
    "use strict";
@@ -2835,7 +2849,9 @@
   (globalThis));
 
 //# unitInfo: Provides: Stdlib__Bool
-(function(globalThis){
+//# shape: Stdlib__Bool:[F(1)*,F(2)*,F(2)*,F(1)*,F(1)*,F(1)*,F(2)*,F(1)*]
+(function
+  (globalThis){
    "use strict";
    var runtime = globalThis.jsoo_runtime, caml_hash = runtime.caml_hash;
    function equal(_b_, _a_){return _b_ === _a_ ? 1 : 0;}
@@ -2873,6 +2889,7 @@
 
 //# unitInfo: Provides: Stdlib__Char
 //# unitInfo: Requires: Stdlib
+//# shape: Stdlib__Char:[F(1),F(1),F(1)*,F(1)*,F(2)*,F(2)*,F(2)*,F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -2974,6 +2991,7 @@
 
 //# unitInfo: Provides: Stdlib__Uchar
 //# unitInfo: Requires: Stdlib
+//# shape: Stdlib__Uchar:[N,N,N,N,F(1),F(1),F(1)*,F(1),F(1)*,F(1)*,F(1)*,F(1)*,F(1),F(1)*,F(2)*,F(2)*,F(2)*,F(1)*,F(1)*,F(1)*,F(1)*,F(2)*,F(1)*,F(1),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -3143,6 +3161,7 @@
 
 //# unitInfo: Provides: Stdlib__List
 //# unitInfo: Requires: Stdlib
+//# shape: Stdlib__List:[F(1),F(2),F(2),F(1)*,F(2)*,F(1),F(1),F(2),F(2),F(1),F(2),F(2),F(2),F(1),F(1),F(3),F(3),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(3),F(3),F(3),F(3),F(3),F(4),F(4),F(2),F(2),F(3),F(3),F(2),F(2),F(2),F(2),F(1)*->F(1),F(2),F(1)*->F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(3),F(1)*->F(1)*,F(1)]
 (function
   (globalThis){
    "use strict";
@@ -4778,7 +4797,9 @@
   (globalThis));
 
 //# unitInfo: Provides: Stdlib__Int
-(function(globalThis){
+//# shape: Stdlib__Int:[N,N,N,F(1)*,N,N,F(1)*,F(2)*,F(2)*,F(2)*,F(2)*,F(1)*,F(2)*,F(1)*]
+(function
+  (globalThis){
    "use strict";
    var runtime = globalThis.jsoo_runtime, caml_hash = runtime.caml_hash;
    function abs(x){
@@ -4826,6 +4847,7 @@
 
 //# unitInfo: Provides: Stdlib__Bytes
 //# unitInfo: Requires: Stdlib, Stdlib__Char, Stdlib__Int, Stdlib__Seq, Stdlib__Sys, Stdlib__Uchar
+//# shape: Stdlib__Bytes:[F(2),F(2),N,F(1),F(1),F(1),F(3),F(3),F(3),F(4),F(5),F(5),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(3),F(2),F(2),F(1),F(1),F(2),F(2),F(2),F(2),F(3),F(3),F(3),F(3),F(2),F(3),F(3),F(1),F(1),F(1),F(1),F(2)*,F(2)*,F(2),F(2),F(1),F(1)*,F(2),F(1)*->F(1),F(1)*->F(1),F(1),F(2),F(3),F(1),F(2),F(3),F(1),F(2),F(3),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -6387,6 +6409,7 @@
 
 //# unitInfo: Provides: Stdlib__String
 //# unitInfo: Requires: Stdlib, Stdlib__Bytes
+//# shape: Stdlib__String:[F(2),F(2),N,F(1),F(1),F(5),F(2),F(2)*,F(2)*,F(2)*,F(2),F(2),F(3),F(3),F(2),F(3),F(2),F(2),F(2),F(3),F(3),F(2),F(2),F(1),F(1),F(1),F(1),F(1),F(1),F(2),F(2),F(3),F(3),F(3),F(3),F(2),F(2),F(2),F(2),F(1),F(1),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -6955,7 +6978,9 @@
   (globalThis));
 
 //# unitInfo: Provides: Stdlib__Unit
-(function(globalThis){
+//# shape: Stdlib__Unit:[F(2)*,F(2)*,F(1)*]
+(function
+  (globalThis){
    "use strict";
    var runtime = globalThis.jsoo_runtime, cst = "()";
    function equal(_a_, param){
@@ -6975,6 +7000,7 @@
 
 //# unitInfo: Provides: Stdlib__Marshal
 //# unitInfo: Requires: Stdlib, Stdlib__Bytes
+//# shape: Stdlib__Marshal:[F(3),F(5),F(1),F(2),F(2),N,F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -7055,6 +7081,7 @@
 
 //# unitInfo: Provides: Stdlib__Array
 //# unitInfo: Requires: Stdlib, Stdlib__Seq, Stdlib__String
+//# shape: Stdlib__Array:[F(2),F(3),F(3),F(2)*,F(1)*,F(3),F(1)*,F(4),F(5),F(1),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(3),F(3),F(3),F(3),F(2),F(2),F(3),F(3),F(2),F(2),F(2),F(2),F(2),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(1)*->F(1)*,F(1)*->F(1)*,F(1),[]]
 (function
   (globalThis){
    "use strict";
@@ -8028,6 +8055,7 @@
 
 //# unitInfo: Provides: Stdlib__Float
 //# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__List, Stdlib__Seq
+//# shape: Stdlib__Float:[N,N,N,F(1)*,F(1)*,N,N,N,N,N,N,N,N,N,F(1)*,F(1)*,F(1)*,F(1)*,F(1),F(1),F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(1)*,N,N]
 (function
   (globalThis){
    "use strict";
@@ -9137,6 +9165,7 @@
 
 //# unitInfo: Provides: Stdlib__Int32
 //# unitInfo: Requires: Stdlib, Stdlib__Sys
+//# shape: Stdlib__Int32:[N,N,N,F(2),F(2),F(1)*,F(1)*,F(1)*,N,N,F(1)*,F(1)*,F(1),F(1)*,F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -9272,6 +9301,7 @@
 
 //# unitInfo: Provides: Stdlib__Int64
 //# unitInfo: Requires: Stdlib
+//# shape: Stdlib__Int64:[N,N,N,F(2),F(2),F(1)*,F(1)*,F(1)*,N,N,F(1)*,F(1)*,F(1),F(1)*,F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -9420,6 +9450,7 @@
 
 //# unitInfo: Provides: Stdlib__Nativeint
 //# unitInfo: Requires: Stdlib, Stdlib__Sys
+//# shape: Stdlib__Nativeint:[N,N,N,F(2),F(2),F(1)*,F(1)*,F(1)*,N,N,N,F(1)*,F(1)*,F(1),F(1)*,F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(2)*,F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -9543,6 +9574,7 @@
 
 //# unitInfo: Provides: Stdlib__Lexing
 //# unitInfo: Requires: Stdlib, Stdlib__Bytes, Stdlib__Int, Stdlib__Sys
+//# shape: Stdlib__Lexing:[N,F(2)*,F(2),F(2)*,F(2),F(2),F(1)*,F(1),F(2),F(1)*,F(1)*,F(1)*,F(1)*,F(1),F(1),F(3),F(3),F(2),F(2),F(3),F(3)]
 (function
   (globalThis){
    "use strict";
@@ -9840,6 +9872,7 @@
 
 //# unitInfo: Provides: Stdlib__Parsing
 //# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Lexing, Stdlib__Obj
+//# shape: Stdlib__Parsing:[F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),F(1),N,F(1),N,F(4),F(2),F(1),F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -10098,6 +10131,7 @@
 
 //# unitInfo: Provides: Stdlib__Set
 //# unitInfo: Requires: Stdlib, Stdlib__List, Stdlib__Seq
+//# shape: Stdlib__Set:[F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -11157,6 +11191,7 @@
 
 //# unitInfo: Provides: Stdlib__Map
 //# unitInfo: Requires: Stdlib, Stdlib__List, Stdlib__Seq
+//# shape: Stdlib__Map:[F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -12200,6 +12235,7 @@
 
 //# unitInfo: Provides: Stdlib__Stack
 //# unitInfo: Requires: Stdlib__List, Stdlib__Seq
+//# shape: Stdlib__Stack:[N,F(1)*,F(2),F(1),F(1),F(1),F(1),F(1)*,F(1),F(1)*,F(1)*,F(1)*,F(2),F(3),F(1),F(2),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -12336,6 +12372,7 @@
 
 //# unitInfo: Provides: Stdlib__Queue
 //# unitInfo: Requires: Stdlib__Seq
+//# shape: Stdlib__Queue:[N,F(1)*,F(2),F(2),F(1),F(1),F(1),F(1),F(1)*,F(1),F(1),F(1),F(1),F(1)*,F(1)*,F(2),F(3),F(2),F(1)*->F(1)*,F(2),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -12552,6 +12589,7 @@
 
 //# unitInfo: Provides: Stdlib__Buffer
 //# unitInfo: Requires: Stdlib, Stdlib__Bytes, Stdlib__Seq, Stdlib__String, Stdlib__Sys
+//# shape: Stdlib__Buffer:[F(1)*,F(1),F(1),F(3),F(5),F(2),F(1)*,F(1),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(4),F(4),F(3),F(2),F(3),F(1)*->F(1),F(1)*->F(1),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -13203,7 +13241,9 @@
   (globalThis));
 
 //# unitInfo: Provides: Stdlib__Mutex
-(function(globalThis){
+//# shape: Stdlib__Mutex:[F(1),F(1),F(1),F(1),F(2)]
+(function
+  (globalThis){
    "use strict";
    var
     runtime = globalThis.jsoo_runtime,
@@ -13243,7 +13283,9 @@
   (globalThis));
 
 //# unitInfo: Provides: Stdlib__Condition
-(function(globalThis){
+//# shape: Stdlib__Condition:[F(1),F(2),F(1),F(1)]
+(function
+  (globalThis){
    "use strict";
    var
     runtime = globalThis.jsoo_runtime,
@@ -13260,6 +13302,7 @@
 
 //# unitInfo: Provides: Stdlib__Semaphore
 //# unitInfo: Requires: Stdlib, Stdlib__Condition, Stdlib__Mutex
+//# shape: Stdlib__Semaphore:[[F(1),F(1),F(1),F(1),F(1)*],[F(1),F(1),F(1),F(1)]]
 (function
   (globalThis){
    "use strict";
@@ -13369,6 +13412,7 @@
 
 //# unitInfo: Provides: Stdlib__Domain
 //# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Atomic, Stdlib__Condition, Stdlib__List, Stdlib__Mutex
+//# shape: Stdlib__Domain:[F(1),F(1),F(1)*,F(1),F(1),F(1),F(1),F(1),F(1),F(1),N]
 (function
   (globalThis){
    "use strict";
@@ -13647,6 +13691,7 @@
 
 //# unitInfo: Provides: CamlinternalFormat
 //# unitInfo: Requires: CamlinternalFormatBasics, Stdlib, Stdlib__Buffer, Stdlib__Bytes, Stdlib__Char, Stdlib__Int, Stdlib__String, Stdlib__Sys
+//# shape: CamlinternalFormat:[F(2),F(1),F(1),F(2),F(1),F(2)*,F(3),F(3),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(1)*,F(1),F(1),F(1),F(1),F(1),F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -20763,6 +20808,7 @@
 
 //# unitInfo: Provides: Stdlib__Printf
 //# unitInfo: Requires: CamlinternalFormat, Stdlib, Stdlib__Buffer
+//# shape: Stdlib__Printf:[F(2),F(1),F(1),F(1),F(2),F(2),F(2),F(3),F(3),F(2),F(3),F(3),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -20879,6 +20925,7 @@
 
 //# unitInfo: Provides: Stdlib__Arg
 //# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Buffer, Stdlib__Int, Stdlib__List, Stdlib__Printf, Stdlib__String, Stdlib__Sys
+//# shape: Stdlib__Arg:[F(3),F(3),F(5),F(5),F(5),F(3),N,N,F(2),F(2),F(2),N,F(1),F(1),F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -21730,6 +21777,7 @@
 
 //# unitInfo: Provides: Stdlib__Printexc
 //# unitInfo: Requires: Stdlib, Stdlib__Atomic, Stdlib__Buffer, Stdlib__Obj, Stdlib__Printf
+//# shape: Stdlib__Printexc:[F(1),F(1),F(2),F(2),F(1),F(1),F(1),F(1),F(1),F(1),F(1)*,F(1)*,F(2),F(1),F(2),F(1),F(1),F(1),N,F(1)*,F(2),F(1),F(1),F(1),F(1),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -22338,6 +22386,7 @@
 
 //# unitInfo: Provides: Stdlib__Fun
 //# unitInfo: Requires: Stdlib, Stdlib__Printexc
+//# shape: Stdlib__Fun:[F(2)*,F(3),F(3),F(2),F(2),N]
 (function
   (globalThis){
    "use strict";
@@ -22436,6 +22485,7 @@
 
 //# unitInfo: Provides: Stdlib__Gc
 //# unitInfo: Requires: Stdlib, Stdlib__Atomic, Stdlib__Domain, Stdlib__Fun, Stdlib__Printf, Stdlib__Sys
+//# shape: Stdlib__Gc:[F(1),F(1),F(2)*,F(2),F(1)*,F(1),F(1),F(1)*,F(1)*,N]
 (function
   (globalThis){
    "use strict";
@@ -22633,6 +22683,7 @@
 
 //# unitInfo: Provides: Stdlib__In_channel
 //# unitInfo: Requires: Stdlib, Stdlib__Bytes, Stdlib__Fun, Stdlib__Sys
+//# shape: Stdlib__In_channel:[N,F(1),F(1),F(3),F(2),F(2),F(4),F(1),F(1),F(1),F(1),F(1),F(2),F(1),F(1),F(4),F(4),F(4),F(4),F(3),N,N,N,F(2),F(1),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -22989,6 +23040,7 @@
 
 //# unitInfo: Provides: Stdlib__Out_channel
 //# unitInfo: Requires: Stdlib, Stdlib__Fun
+//# shape: Stdlib__Out_channel:[N,N,F(1),F(1),F(3),F(2),F(2),F(4),F(1),F(1),F(2),F(2),F(2),F(2),F(4),F(4),F(4),F(1),F(1),N,N,N,F(2),F(1),F(2),F(1),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -23101,6 +23153,7 @@
 
 //# unitInfo: Provides: Stdlib__Digest
 //# unitInfo: Requires: Stdlib, Stdlib__Bytes, Stdlib__Char, Stdlib__In_channel, Stdlib__Int, Stdlib__String
+//# shape: Stdlib__Digest:[F(2)*,F(2)*,F(1),F(1),F(3),F(3),F(2),F(1),F(2),F(1),F(1),F(1),F(1),N,N,N,N]
 (function
   (globalThis){
    "use strict";
@@ -23428,6 +23481,7 @@
 
 //# unitInfo: Provides: Stdlib__Bigarray
 //# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Sys
+//# shape: Stdlib__Bigarray:[N,N,N,N,N,N,N,N,N,N,N,N,N,N,F(1)*,N,N,N,N,N,N,N,F(1),F(1),F(1),F(1),F(2),F(1),F(2),F(3),F(4)]
 (function
   (globalThis){
    "use strict";
@@ -24060,6 +24114,7 @@
 
 //# unitInfo: Provides: Stdlib__Random
 //# unitInfo: Requires: Stdlib, Stdlib__Bigarray, Stdlib__Bytes, Stdlib__Digest, Stdlib__Domain, Stdlib__Int32, Stdlib__Int64, Stdlib__Nativeint, Stdlib__String, Stdlib__Sys
+//# shape: Stdlib__Random:[F(1),F(1),F(1),F(1),F(1),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(1),F(1),F(1),F(1),N,F(1),F(1),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -24637,6 +24692,7 @@
 
 //# unitInfo: Provides: Stdlib__Hashtbl
 //# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Atomic, Stdlib__Domain, Stdlib__Int, Stdlib__Random, Stdlib__Seq, Stdlib__String, Stdlib__Sys
+//# shape: Stdlib__Hashtbl:[F(2),F(1),F(1),F(1),F(3),F(2),F(2),F(2),F(2),F(2),F(3),F(2),F(2),F(3),F(1)*,F(1),F(1),F(2),F(1),F(1)*->F(1),F(1),F(1),F(2),F(2),F(1),F(1)*,F(1)*,F(1)*,F(2)*,F(3)*,F(4)*]
 (function
   (globalThis){
    "use strict";
@@ -25752,6 +25808,7 @@
 
 //# unitInfo: Provides: Stdlib__Weak
 //# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Int, Stdlib__Obj, Stdlib__Sys
+//# shape: Stdlib__Weak:[F(1),F(1)*,F(3),F(2),F(2),F(2),F(4),F(5),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -26326,6 +26383,7 @@
 
 //# unitInfo: Provides: Stdlib__Format
 //# unitInfo: Requires: CamlinternalFormat, Stdlib, Stdlib__Array, Stdlib__Buffer, Stdlib__Bytes, Stdlib__Domain, Stdlib__Int, Stdlib__List, Stdlib__Queue, Stdlib__Seq, Stdlib__Stack, Stdlib__String
+//# shape: Stdlib__Format:[F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(4),F(3),F(2),F(1),F(3),F(2),F(5),F(4),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2)*,F(2),F(1),F(2),F(1),F(3),F(2),F(3),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(1),N,F(2),F(1),F(2)*,F(1),F(2),F(1),F(2)*,F(1),F(1)*,F(3),F(2),F(3),F(2),F(2),F(1),F(2)*,F(1),F(2),F(1),F(2)*,F(1),F(2)*,F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(3),F(2),F(2),F(1),F(2)*,F(1),N,F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2)*,F(1),F(2)*,F(1),F(2),F(1),F(3),F(2),F(2)*,F(1),F(2),F(1),F(2)*,F(1),F(2),F(1),F(2)*,F(1),F(1),F(1),N,F(1),N,F(1),F(1),N,F(1),N,F(1),F(1),F(2),F(2),F(1),F(1)*,F(1),F(1),F(1),F(2),F(1),F(5),F(4),F(4),F(4),F(2),F(4),F(4),F(4),F(1)*->F(1),F(1),F(1),F(1),F(1),F(1),F(2),F(3),F(2),F(3),F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -28552,6 +28610,7 @@
 
 //# unitInfo: Provides: Stdlib__Scanf
 //# unitInfo: Requires: CamlinternalFormat, CamlinternalFormatBasics, Stdlib, Stdlib__Buffer, Stdlib__Bytes, Stdlib__Int, Stdlib__Printf, Stdlib__String
+//# shape: Stdlib__Scanf:[N,N,F(2),F(2),F(2),F(2),F(1),F(1),F(3),F(3),F(3),F(3),F(2),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -30768,6 +30827,7 @@
 
 //# unitInfo: Provides: Stdlib__Callback
 //# unitInfo: Requires: Stdlib, Stdlib__Obj
+//# shape: Stdlib__Callback:[F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -30791,6 +30851,7 @@
 
 //# unitInfo: Provides: CamlinternalOO
 //# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__List, Stdlib__Map, Stdlib__Obj, Stdlib__Sys
+//# shape: CamlinternalOO:[F(1),F(1),F(2),F(3),F(2),F(2),F(2),F(2),F(2),F(3),F(2),F(4),F(1),F(2),N,F(1),F(1),F(6),F(2),F(3),F(1)*,F(1),F(1),F(2),F(2),F(3),F(2),F(2),N,F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -31759,6 +31820,7 @@
 
 //# unitInfo: Provides: Stdlib__Oo
 //# unitInfo: Requires: CamlinternalOO
+//# shape: Stdlib__Oo:[F(1),F(1),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -31777,6 +31839,7 @@
 
 //# unitInfo: Provides: CamlinternalMod
 //# unitInfo: Requires: CamlinternalLazy, CamlinternalOO, Stdlib, Stdlib__Obj
+//# shape: CamlinternalMod:[F(2),F(3)]
 (function
   (globalThis){
    "use strict";
@@ -31948,6 +32011,7 @@
 
 //# unitInfo: Provides: Stdlib__Dynarray
 //# unitInfo: Requires: CamlinternalOO, Stdlib, Stdlib__Array, Stdlib__Obj, Stdlib__Printf, Stdlib__Seq, Stdlib__Sys
+//# shape: Stdlib__Dynarray:[F(1)*,F(2),F(2),F(2),F(3),F(1)*,F(1)*,F(1),F(1),F(1),F(2),F(2),F(2),F(2),F(2),F(3),F(5),F(1),F(1),F(1),F(2),F(1),F(2),F(2),F(2),F(2),F(3),F(3),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(3),F(1),F(1),F(1),F(1),F(1),F(1),F(1)*,F(1),F(1)*,F(1)*,F(2),F(2),F(1),F(2),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -33263,6 +33327,7 @@
 
 //# unitInfo: Provides: Stdlib__Ephemeron
 //# unitInfo: Requires: CamlinternalLazy, Stdlib, Stdlib__Array, Stdlib__Hashtbl, Stdlib__Int, Stdlib__List, Stdlib__Obj, Stdlib__Random, Stdlib__Seq, Stdlib__Sys
+//# shape: Stdlib__Ephemeron:[N,N,N]
 (function
   (globalThis){
    "use strict";
@@ -34523,6 +34588,7 @@
 
 //# unitInfo: Provides: Stdlib__Filename
 //# unitInfo: Requires: Stdlib, Stdlib__Buffer, Stdlib__Domain, Stdlib__List, Stdlib__Printf, Stdlib__Random, Stdlib__String, Stdlib__Sys
+//# shape: Stdlib__Filename:[N,N,N,F(2),F(1),F(1),F(2),F(2),F(2),F(1),F(1),F(1),F(1),F(1),N,F(3),F(5),F(4),F(1),F(1),F(1),F(5)]
 (function
   (globalThis){
    "use strict";
@@ -35531,6 +35597,7 @@
 
 //# unitInfo: Provides: Stdlib__Complex
 //# unitInfo: Requires: Stdlib, Stdlib__Float
+//# shape: Stdlib__Complex:[N,N,N,F(1)*,F(1)*,F(2)*,F(2)*,F(2)*,F(1)*,F(2)*,F(1)*,F(1)*,F(1)*,F(1)*,F(2)*,F(1)*,F(1)*,F(2)*]
 (function
   (globalThis){
    "use strict";
@@ -35669,6 +35736,7 @@
 
 //# unitInfo: Provides: Stdlib__ArrayLabels
 //# unitInfo: Requires: Stdlib__Array
+//# shape: Stdlib__ArrayLabels:[F(2),F(3),F(3),F(2)*,F(1)*,F(3),F(1)*,F(4),F(5),F(1),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(3),F(3),F(3),F(3),F(2),F(2),F(3),F(3),F(2),F(2),F(2),F(2),F(2),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(1)*->F(1)*,F(1)*->F(1)*,F(1),[]]
 (function
   (globalThis){
    "use strict";
@@ -35769,6 +35837,7 @@
 
 //# unitInfo: Provides: Stdlib__ListLabels
 //# unitInfo: Requires: Stdlib__List
+//# shape: Stdlib__ListLabels:[F(1),F(2),F(2),F(1)*,F(2)*,F(1),F(1),F(2),F(2),F(1),F(2),F(2),F(2),F(1),F(1),F(3),F(3),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(3),F(3),F(3),F(3),F(3),F(4),F(4),F(2),F(2),F(3),F(3),F(2),F(2),F(2),F(2),F(1)*->F(1),F(2),F(1)*->F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(3),F(1)*->F(1)*,F(1)]
 (function
   (globalThis){
    "use strict";
@@ -35923,6 +35992,7 @@
 
 //# unitInfo: Provides: Stdlib__BytesLabels
 //# unitInfo: Requires: Stdlib__Bytes
+//# shape: Stdlib__BytesLabels:[F(2),F(2),N,F(1),F(1),F(1),F(3),F(3),F(3),F(4),F(5),F(5),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(3),F(2),F(2),F(1),F(1),F(2),F(2),F(2),F(2),F(3),F(3),F(3),F(3),F(2),F(3),F(3),F(1),F(1),F(1),F(1),F(2)*,F(2)*,F(2),F(2),F(1),F(1)*,F(2),F(1)*->F(1),F(1)*->F(1),F(1),F(2),F(3),F(1),F(2),F(3),F(1),F(2),F(3),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(3),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -36113,6 +36183,7 @@
 
 //# unitInfo: Provides: Stdlib__StringLabels
 //# unitInfo: Requires: Stdlib__String
+//# shape: Stdlib__StringLabels:[F(2),F(2),N,F(1),F(1),F(5),F(2),F(2)*,F(2)*,F(2)*,F(2),F(2),F(3),F(3),F(2),F(3),F(2),F(2),F(2),F(3),F(3),F(2),F(2),F(1),F(1),F(1),F(1),F(1),F(1),F(2),F(2),F(3),F(3),F(3),F(3),F(2),F(2),F(2),F(2),F(1),F(1),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -36258,6 +36329,7 @@
 
 //# unitInfo: Provides: Stdlib__MoreLabels
 //# unitInfo: Requires: Stdlib__Hashtbl, Stdlib__Map, Stdlib__Set
+//# shape: Stdlib__MoreLabels:[[F(2),F(1),F(1),F(1),F(3),F(2),F(2),F(2),F(2),F(2),F(3),F(2),F(2),F(3),F(1)*,F(1),F(1),F(2),F(1),F(1)*->F(1),F(1),F(1),F(2),F(2),F(1),F(1)*,F(1)*,F(1)*,F(2)*,F(3)*,F(4)*],[F(1)*],[F(1)*]]
 (function
   (globalThis){
    "use strict";
@@ -36274,7 +36346,9 @@
   (globalThis));
 
 //# unitInfo: Provides: Stdlib__StdLabels
-(function(globalThis){
+//# shape: Stdlib__StdLabels:[]
+(function
+  (globalThis){
    "use strict";
    var runtime = globalThis.jsoo_runtime, Stdlib_StdLabels = [0];
    runtime.caml_register_global(0, Stdlib_StdLabels, "Stdlib__StdLabels");
@@ -36285,6 +36359,7 @@
 //# unitInfo: Provides: Stdlib__Effect
 //# unitInfo: Requires: Stdlib, Stdlib__Callback, Stdlib__Printexc, Stdlib__Printf
 //# unitInfo: Effects_without_cps: true
+//# shape: Stdlib__Effect:[N,N,[F(2),F(2),F(3),F(3),F(3)],N]
 (function
   (globalThis){
    "use strict";

From 9c9c2208b60cf12979d7c89bef7535cf2ef682d5 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 20 May 2025 15:56:16 +0200
Subject: [PATCH 4/7] Compiler: use shapes to compute arity

This reverts commit 9c0692f8af4d6fafdf0fc428f820cc9753897cc4.
---
 compiler/lib/driver.ml                     |    5 +-
 compiler/lib/specialize.ml                 |   32 +-
 compiler/lib/specialize.mli                |    3 +-
 compiler/tests-full/stdlib.cma.expected.js | 4063 +++++++++-----------
 4 files changed, 1918 insertions(+), 2185 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 62f678118b..f77b4542b9 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -62,7 +62,10 @@ let inline profile p =
 
 let specialize_1 (p, info) =
   if debug () then Format.eprintf "Specialize...@.";
-  Specialize.f ~function_arity:(fun f -> Specialize.function_arity info f) p
+  let return_values = Code.Var.Map.empty in
+  Specialize.f
+    ~function_arity:(fun f -> Specialize.function_arity ~return_values info f)
+    p
 
 let specialize_js (p, info) =
   if debug () then Format.eprintf "Specialize js...@.";
diff --git a/compiler/lib/specialize.ml b/compiler/lib/specialize.ml
index 769e510c41..a6009fcc6d 100644
--- a/compiler/lib/specialize.ml
+++ b/compiler/lib/specialize.ml
@@ -19,7 +19,6 @@
  *)
 open! Stdlib
 open Code
-open Flow
 
 let times = Debug.find "times"
 
@@ -27,33 +26,10 @@ let stats = Debug.find "stats"
 
 let debug_stats = Debug.find "stats-debug"
 
-let function_arity info x =
-  let rec arity info x acc =
-    get_approx
-      info
-      (fun x ->
-        match Flow.Info.def info x with
-        | Some (Closure (l, _, _)) -> Some (List.length l)
-        | Some (Special (Alias_prim prim)) -> (
-            try Some (Primitive.arity prim) with Not_found -> None)
-        | Some (Apply { f; args; _ }) -> (
-            if List.mem ~eq:Var.equal f acc
-            then None
-            else
-              match arity info f (f :: acc) with
-              | Some n ->
-                  let diff = n - List.length args in
-                  if diff > 0 then Some diff else None
-              | None -> None)
-        | _ -> None)
-      None
-      (fun u v ->
-        match u, v with
-        | Some n, Some m when n = m -> u
-        | _ -> None)
-      x
-  in
-  arity info x []
+let function_arity ~return_values info x =
+  match Flow.the_shape_of ~return_values ~pure:Pure_fun.empty info x with
+  | Top | Block _ -> None
+  | Function { arity; _ } -> Some arity
 
 let add_event loc instrs =
   match loc with
diff --git a/compiler/lib/specialize.mli b/compiler/lib/specialize.mli
index 149f33bd76..5a1a8f7a2a 100644
--- a/compiler/lib/specialize.mli
+++ b/compiler/lib/specialize.mli
@@ -18,7 +18,8 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *)
 
-val function_arity : Flow.Info.t -> Code.Var.t -> int option
+val function_arity :
+  return_values:Code.Var.Set.t Code.Var.Map.t -> Flow.Info.t -> Code.Var.t -> int option
 
 val f : function_arity:(Code.Var.t -> int option) -> Code.program -> Code.program
 
diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js
index e4194dfd2d..f6416f488c 100644
--- a/compiler/tests-full/stdlib.cma.expected.js
+++ b/compiler/tests-full/stdlib.cma.expected.js
@@ -388,11 +388,6 @@
             ? 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(),
     CamlinternalFormatBasics = global_data.CamlinternalFormatBasics,
@@ -819,7 +814,7 @@
      fmt1 = _f_[1],
      s2 =  /*<<stdlib.ml:546:17>>*/ "%," + str2;
      /*<<stdlib.ml:545:10>>*/ return [0,
-            caml_call2(CamlinternalFormatBasics[3], fmt1, fmt2),
+            CamlinternalFormatBasics[3].call(null, fmt1, fmt2),
             str1 + s2] /*<<stdlib.ml:545:55>>*/ ;
     /*<<stdlib.ml:546:29>>*/ }
    var exit_function =  /*<<stdlib.ml:316:34>>*/ [0, flush_all];
@@ -1215,13 +1210,7 @@
     runtime = globalThis.jsoo_runtime,
     cst_Obj_extension_constructor$1 = "Obj.extension_constructor",
     caml_check_bound = runtime.caml_check_bound,
-    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
+    caml_obj_tag = runtime.caml_obj_tag,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_Sys = global_data.Stdlib__Sys;
@@ -1254,13 +1243,14 @@
       (is_block(slot) &&  /*<<obj.ml:81:28>>*/ caml_obj_tag(slot) === 248){var name =  /*<<obj.ml:81:69>>*/ slot[1]; break a;}
      var
       name =
-         /*<<obj.ml:82:50>>*/  /*<<obj.ml:82:11>>*/ caml_call1
-         (Stdlib[1], cst_Obj_extension_constructor$0);
+         /*<<obj.ml:82:50>>*/  /*<<obj.ml:82:11>>*/ Stdlib[1].call
+         (null, cst_Obj_extension_constructor$0);
     }
      /*<<obj.ml:84:9>>*/ return caml_obj_tag(name) === 252
             ? slot
-            :  /*<<obj.ml:85:11>>*/ caml_call1
-              (Stdlib[1], cst_Obj_extension_constructor) /*<<obj.ml:85:50>>*/ ;
+            :  /*<<obj.ml:85:11>>*/ Stdlib
+               [1].call
+              (null, cst_Obj_extension_constructor) /*<<obj.ml:85:50>>*/ ;
    }
    function name(slot){ /*<<obj.ml:88:30>>*/ return slot[1];}
    function id(slot){ /*<<obj.ml:91:30>>*/ return slot[2];}
@@ -1279,7 +1269,7 @@
      _d_ =  /*<<obj.ml:105:4>>*/ 0 <= l ? 1 : 0,
      _e_ = _d_ ? l <= max_ephe_length ? 1 : 0 : _d_;
     if(1 - _e_)
-      /*<<obj.ml:106:6>>*/ caml_call1(Stdlib[1], cst_Obj_Ephemeron_create);
+      /*<<obj.ml:106:6>>*/ Stdlib[1].call(null, cst_Obj_Ephemeron_create);
      /*<<obj.ml:107:4>>*/ return runtime.caml_ephe_create(l) /*<<obj.ml:107:12>>*/ ;
    }
    function length(x){
@@ -1290,7 +1280,7 @@
      _b_ =  /*<<obj.ml:112:4>>*/ 0 <= o ? 1 : 0,
      _d_ = _b_ ? o <  /*<<obj.ml:112:26>>*/ length(e) ? 1 : 0 : _b_,
      _c_ =  /*<<obj.ml:112:4>>*/ 1 - _d_;
-    return _c_ ?  /*<<obj.ml:113:6>>*/ caml_call1(Stdlib[1], msg) : _c_ /*<<obj.ml:113:21>>*/ ;
+    return _c_ ?  /*<<obj.ml:113:6>>*/ Stdlib[1].call(null, msg) : _c_ /*<<obj.ml:113:21>>*/ ;
    }
    function get_key(e, o){
      /*<<obj.ml:117:4>>*/ raise_if_invalid_offset
@@ -1334,8 +1324,8 @@
          : _a_;
       /*<<obj.ml:147:9>>*/ return _b_;
     }
-     /*<<obj.ml:146:9>>*/ return caml_call1
-            (Stdlib[1], cst_Obj_Ephemeron_blit_key) /*<<obj.ml:147:46>>*/ ;
+     /*<<obj.ml:146:9>>*/ return Stdlib[1].call
+            (null, cst_Obj_Ephemeron_blit_key) /*<<obj.ml:147:46>>*/ ;
    }
    var
     Stdlib_Obj =
@@ -1389,13 +1379,8 @@
 (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
+    runtime = globalThis.jsoo_runtime,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Obj = global_data.Stdlib__Obj,
     cst_Id = "Id",
@@ -1405,8 +1390,8 @@
     return [0, Id];
     /*<<type.ml:32:57>>*/ }
    function uid(A){
-    var _a_ =  /*<<type.ml:35:33>>*/ caml_call1(Stdlib_Obj[22][1], A[1]);
-     /*<<type.ml:35:72>>*/ return caml_call1(Stdlib_Obj[22][3], _a_);
+    var _a_ =  /*<<type.ml:35:33>>*/ Stdlib_Obj[22][1].call(null, A[1]);
+     /*<<type.ml:35:72>>*/ return Stdlib_Obj[22][3].call(null, _a_);
    }
    function provably_equal(A, B){
      /*<<type.ml:40:4>>*/ return A[1] === B[1] ? _a_ : 0 /*<<type.ml:40:50>>*/ ;
@@ -1544,18 +1529,13 @@
             ? 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 caml_call2(CamlinternalLazy[3], 1, l) /*<<lazy.ml:56:61>>*/ ;
+     /*<<lazy.ml:56:18>>*/ return CamlinternalLazy[3].call(null, 1, l) /*<<lazy.ml:56:61>>*/ ;
    }
    function from_fun(f){
     var x =  /*<<lazy.ml:59:10>>*/ runtime.caml_obj_block(Stdlib_Obj[8], 1);
@@ -1583,7 +1563,7 @@
               var _d_ = x[1];
              else{
               if(246 !== _c_ && 244 !== _c_){var _d_ = x; break a;}
-              var _d_ = caml_call1(CamlinternalLazy[2], x);
+              var _d_ = CamlinternalLazy[2].call(null, x);
              }
              return caml_call1(f, _d_);
             }] /*<<lazy.ml:75:2>>*/ ;
@@ -1598,7 +1578,7 @@
                var _c_ = x[1];
               else{
                if(246 !== _b_ && 244 !== _b_){var _c_ = x; break a;}
-               var _c_ = caml_call1(CamlinternalLazy[2], x);
+               var _c_ = CamlinternalLazy[2].call(null, x);
               }
               return caml_call1(f, _c_);
              }] /*<<lazy.ml:80:7>>*/ ;
@@ -1608,7 +1588,7 @@
      var _b_ = x[1];
     else{
      if(246 !== _a_ && 244 !== _a_){var _b_ = x; break a;}
-     var _b_ = caml_call1(CamlinternalLazy[2], x);
+     var _b_ = CamlinternalLazy[2].call(null, x);
     }
      /*<<lazy.ml:79:16>>*/ return  /*<<lazy.ml:79:29>>*/ from_val
             ( /*<<lazy.ml:79:16>>*/ caml_call1(f, _b_)) /*<<lazy.ml:80:25>>*/ ;
@@ -1630,7 +1610,7 @@
 
 //# unitInfo: Provides: Stdlib__Seq
 //# unitInfo: Requires: CamlinternalLazy, Stdlib, Stdlib__Atomic, Stdlib__Lazy
-//# shape: Stdlib__Seq:[F(1),F(1),F(1),F(2),F(3),F(2),F(3),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(4),F(3),F(3),F(3),F(3),F(1)*,F(2)*,F(3)*,F(2),F(3),F(2)*,F(2),F(2),F(2)*->F(1)*,F(3),F(2)*->F(1),F(3),F(3),F(3)*->F(1)*,F(2),F(2),F(3),F(3),F(3),F(1)->F(1),N,F(1)->F(1),F(2),F(3),F(2),F(3),F(3),F(3),F(4),F(3),F(4),F(2)*,F(3)*->F(1),F(1)*,F(1)*,F(2)*,F(2)*,F(1)*->F(1),F(1)*->F(1),F(2)*]
+//# shape: Stdlib__Seq:[F(1),F(1),F(1),F(2),F(3),F(2),F(3),F(2),F(2),F(2),F(2),F(2),F(2),F(3),F(4),F(3),F(3),F(3),F(3),F(1)*,F(2)*,F(3)*,F(2),F(3),F(2)*,F(2),F(2),F(2)*->F(1)*,F(3),F(2)*->F(1),F(3),F(3),F(3)*->F(1)*,F(2),F(2),F(3),F(3),F(3),F(1)->F(1),N,F(1)*->F(1),F(2),F(3),F(2),F(3),F(3),F(3),F(4),F(3),F(4),F(2)*,F(3)*->F(1),F(1)*,F(1)*,F(2)*,F(2)*,F(1)*->F(1),F(1)*->F(1),F(2)*]
 (function
   (globalThis){
    "use strict";
@@ -2032,7 +2012,7 @@
     /*<<seq.ml:268:7>>*/ }
    function init(n, f){
      /*<<seq.ml:271:2>>*/ if(0 > n)
-      /*<<seq.ml:272:4>>*/ return caml_call1(Stdlib[1], cst_Seq_init) /*<<seq.ml:274:18>>*/ ;
+      /*<<seq.ml:272:4>>*/ return Stdlib[1].call(null, cst_Seq_init) /*<<seq.ml:274:18>>*/ ;
     var _n_ =  /*<<seq.ml:274:4>>*/ 0;
     return function(_o_){
       /*<<?>>*/ return init_aux(f, _n_, n, _o_);} /*<<seq.ml:274:4>>*/ ;
@@ -2127,7 +2107,7 @@
    }
    function take(n, xs){
      /*<<seq.ml:365:2>>*/ if(n < 0)
-      /*<<seq.ml:365:16>>*/ caml_call1(Stdlib[1], cst_Seq_take);
+      /*<<seq.ml:365:16>>*/ Stdlib[1].call(null, cst_Seq_take);
      /*<<seq.ml:366:2>>*/ return take_aux(n, xs) /*<<seq.ml:366:15>>*/ ;
    }
    function drop(n, xs){
@@ -2151,7 +2131,7 @@
                  xs$0 = xs$1;
                 }
                 /*<<seq.ml:392:21>>*/ }
-            :  /*<<seq.ml:387:16>>*/ caml_call1(Stdlib[1], cst_Seq_drop) /*<<seq.ml:392:21>>*/ ;
+            :  /*<<seq.ml:387:16>>*/ Stdlib[1].call(null, cst_Seq_drop) /*<<seq.ml:392:21>>*/ ;
    }
    function take_while(p, xs, param){
     var match =  /*<<seq.ml:395:8>>*/ caml_call1(xs, 0);
@@ -2209,12 +2189,12 @@
      var xs$0 =  /*<<seq.ml:460:14>>*/ match[2], x = match[1];
       /*<<seq.ml:464:17>>*/ return [0, x, memoize(xs$0)] /*<<seq.ml:464:27>>*/ ;
      /*<<seq.ml:464:28>>*/ }
-    var s =  /*<<seq.ml:434:14>>*/ caml_call1(to_lazy, s$0);
+    var s =  /*<<seq.ml:434:14>>*/ to_lazy(s$0);
      /*<<seq.ml:429:4>>*/ return function(param){
      var _h_ =  /*<<seq.ml:429:14>>*/ runtime.caml_obj_tag(s);
      if(250 === _h_) return s[1];
      if(246 !== _h_ && 244 !== _h_) return s;
-     return caml_call1(CamlinternalLazy[2], s) /*<<seq.ml:429:26>>*/ ;} /*<<seq.ml:429:4>>*/ ;
+     return CamlinternalLazy[2].call(null, s) /*<<seq.ml:429:26>>*/ ;} /*<<seq.ml:429:4>>*/ ;
     /*<<seq.ml:465:3>>*/ }
    function once(xs){
     function f(param){
@@ -2223,10 +2203,10 @@
      var xs$0 =  /*<<seq.ml:469:14>>*/ match[2], x = match[1];
       /*<<seq.ml:473:17>>*/ return [0, x, once(xs$0)] /*<<seq.ml:473:24>>*/ ;
      /*<<seq.ml:473:25>>*/ }
-    var action =  /*<<seq.ml:448:17>>*/ caml_call1(Stdlib_Atomic[1], f);
+    var action =  /*<<seq.ml:448:17>>*/ Stdlib_Atomic[1].call(null, f);
      /*<<seq.ml:449:4>>*/ return function(param){
      var
-      f =  /*<<seq.ml:453:14>>*/ caml_call2(Stdlib_Atomic[5], action, failure);
+      f =  /*<<seq.ml:453:14>>*/ Stdlib_Atomic[5].call(null, action, failure);
       /*<<seq.ml:454:6>>*/ return caml_call1(f, 0) /*<<seq.ml:454:9>>*/ ;} /*<<seq.ml:449:4>>*/ ;
     /*<<seq.ml:474:3>>*/ }
    function zip(xs, ys, param){
@@ -2556,7 +2536,7 @@
 
 //# unitInfo: Provides: Stdlib__Option
 //# unitInfo: Requires: Stdlib, Stdlib__Seq
-//# shape: Stdlib__Option:[N,F(1)*,F(2)*,F(1),F(2),F(1)*,F(2),F(3),F(2),F(1)*,F(1)*,F(3),F(3),F(2)*,F(1)*,F(1)]
+//# shape: Stdlib__Option:[N,F(1)*,F(2)*,F(1),F(2),F(1)*,F(2),F(3),F(2),F(1)*,F(1)*,F(3),F(3),F(2)*,F(1)*,F(1)*->F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -2586,7 +2566,7 @@
     /*<<option.ml:20:65>>*/ }
    function get(param){
      /*<<option.ml:21:10>>*/ if(! param)
-      /*<<option.ml:21:41>>*/ return caml_call1(Stdlib[1], cst_option_is_None) /*<<option.ml:21:69>>*/ ;
+      /*<<option.ml:21:41>>*/ return Stdlib[1].call(null, cst_option_is_None) /*<<option.ml:21:69>>*/ ;
     var v =  /*<<option.ml:21:10>>*/ param[1];
      /*<<option.ml:21:29>>*/ return v;
     /*<<option.ml:21:69>>*/ }
@@ -2653,9 +2633,12 @@
    function to_seq(param){
      /*<<option.ml:43:13>>*/ if(! param)
       /*<<option.ml:43:30>>*/ return Stdlib_Seq[20];
-    var v =  /*<<option.ml:43:13>>*/ param[1];
-     /*<<option.ml:43:52>>*/ return caml_call1(Stdlib_Seq[21], v) /*<<option.ml:43:64>>*/ ;
-   }
+    var
+     v =  /*<<option.ml:43:13>>*/ param[1],
+     _a_ =  /*<<option.ml:43:52>>*/ Stdlib_Seq[21];
+    return function(_b_){
+      /*<<?>>*/ return _a_(v, _b_);} /*<<option.ml:43:52>>*/ ;
+    /*<<option.ml:43:64>>*/ }
    var
     Stdlib_Option =
        /*<<?>>*/ [0,
@@ -2682,7 +2665,7 @@
 
 //# unitInfo: Provides: Stdlib__Result
 //# unitInfo: Requires: Stdlib, Stdlib__Seq
-//# shape: Stdlib__Result:[F(1)*,F(1)*,F(2)*,F(1),F(1),F(2),F(1)*,F(2),F(2),F(3),F(2),F(2),F(1)*,F(1)*,F(4),F(4),F(1)*,F(1)*,F(1)]
+//# shape: Stdlib__Result:[F(1)*,F(1)*,F(2)*,F(1),F(1),F(2),F(1)*,F(2),F(2),F(3),F(2),F(2),F(1)*,F(1)*,F(4),F(4),F(1)*,F(1)*,F(1)*->F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -2717,14 +2700,13 @@
     /*<<result.ml:20:66>>*/ }
    function get_ok(param){
      /*<<result.ml:21:13>>*/ if(0 !== param[0])
-      /*<<result.ml:21:45>>*/ return caml_call1
-             (Stdlib[1], cst_result_is_Error) /*<<result.ml:21:76>>*/ ;
+      /*<<result.ml:21:45>>*/ return Stdlib[1].call(null, cst_result_is_Error) /*<<result.ml:21:76>>*/ ;
     var v =  /*<<result.ml:21:13>>*/ 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 caml_call1(Stdlib[1], cst_result_is_Ok) /*<<result.ml:22:76>>*/ ;
+      /*<<result.ml:22:48>>*/ return Stdlib[1].call(null, cst_result_is_Ok) /*<<result.ml:22:76>>*/ ;
     var e =  /*<<result.ml:22:16>>*/ param[1];
      /*<<result.ml:22:36>>*/ return e;
     /*<<result.ml:22:76>>*/ }
@@ -2818,9 +2800,12 @@
    function to_seq(param){
      /*<<result.ml:46:13>>*/ if(0 !== param[0])
       /*<<result.ml:46:56>>*/ return Stdlib_Seq[20];
-    var v =  /*<<result.ml:46:13>>*/ param[1];
-     /*<<result.ml:46:30>>*/ return caml_call1(Stdlib_Seq[21], v) /*<<result.ml:46:65>>*/ ;
-   }
+    var
+     v =  /*<<result.ml:46:13>>*/ param[1],
+     _a_ =  /*<<result.ml:46:30>>*/ Stdlib_Seq[21];
+    return function(_b_){
+      /*<<?>>*/ return _a_(v, _b_);} /*<<result.ml:46:30>>*/ ;
+    /*<<result.ml:46:65>>*/ }
    var
     Stdlib_Result =
        /*<<?>>*/ [0,
@@ -2898,13 +2883,7 @@
     caml_bytes_unsafe_set = runtime.caml_bytes_unsafe_set,
     caml_create_bytes = runtime.caml_create_bytes,
     caml_hash = runtime.caml_hash,
-    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
+    caml_string_of_bytes = runtime.caml_string_of_bytes,
     global_data = runtime.caml_get_global_data(),
     cst = "\\\\",
     cst$0 = "\\'",
@@ -2917,7 +2896,7 @@
    function chr(n){
      /*<<char.ml:22:2>>*/ if(0 <= n && 255 >= n)
       /*<<char.ml:22:55>>*/ return n;
-     /*<<char.ml:22:27>>*/ return caml_call1(Stdlib[1], cst_Char_chr) /*<<char.ml:22:67>>*/ ;
+     /*<<char.ml:22:27>>*/ return Stdlib[1].call(null, cst_Char_chr) /*<<char.ml:22:67>>*/ ;
    }
    function escaped(c){
     a:
@@ -3000,18 +2979,7 @@
     cst_uchar_ml = "uchar.ml",
     caml_format_int = runtime.caml_format_int,
     caml_hash = runtime.caml_hash,
-    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
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
     global_data = runtime.caml_get_global_data(),
     err_no_pred = "U+0000 has no predecessor",
     err_no_succ = "U+10FFFF has no successor",
@@ -3027,7 +2995,7 @@
             ? hi_bound
             : u
               === 1114111
-              ?  /*<<uchar.ml:35:18>>*/ caml_call1(Stdlib[1], err_no_succ)
+              ?  /*<<uchar.ml:35:18>>*/ Stdlib[1].call(null, err_no_succ)
               : u + 1 | 0 /*<<uchar.ml:36:7>>*/ ;
    }
    function pred(u){
@@ -3035,7 +3003,7 @@
             ? lo_bound
             : u
               === 0
-              ?  /*<<uchar.ml:40:18>>*/ caml_call1(Stdlib[1], err_no_pred)
+              ?  /*<<uchar.ml:40:18>>*/ Stdlib[1].call(null, err_no_pred)
               : u - 1 | 0 /*<<uchar.ml:41:7>>*/ ;
    }
    function is_valid(i){
@@ -3052,11 +3020,11 @@
      /*<<uchar.ml:44:18>>*/ if(is_valid(i))  /*<<uchar.ml:44:34>>*/ return i;
     var
      _f_ =
-        /*<<uchar.ml:20:19>>*/  /*<<uchar.ml:20:36>>*/ caml_call2
-        (Stdlib[28],
+        /*<<uchar.ml:20:19>>*/  /*<<uchar.ml:20:36>>*/ Stdlib[28].call
+        (null,
           /*<<uchar.ml:20:19>>*/ caml_format_int("%X", i),
          cst_is_not_a_Unicode_scalar_va);
-     /*<<uchar.ml:44:67>>*/ return caml_call1(Stdlib[1], _f_);
+     /*<<uchar.ml:44:67>>*/ return Stdlib[1].call(null, _f_);
    }
    function is_char(u){
      /*<<uchar.ml:48:16>>*/ return u < 256 ? 1 : 0;
@@ -3068,12 +3036,10 @@
      /*<<uchar.ml:51:2>>*/ if(255 >= u)  /*<<uchar.ml:52:2>>*/ return u;
     var
      _e_ =
-        /*<<uchar.ml:21:30>>*/ caml_call2
-        (Stdlib[28],
-         caml_format_int("%04X", u),
-         cst_is_not_a_latin1_character),
-     _f_ =  /*<<uchar.ml:21:80>>*/ caml_call2(Stdlib[28], cst_U, _e_);
-     /*<<uchar.ml:51:48>>*/ return caml_call1(Stdlib[1], _f_) /*<<uchar.ml:52:19>>*/ ;
+        /*<<uchar.ml:21:30>>*/ Stdlib[28].call
+        (null, caml_format_int("%04X", u), cst_is_not_a_latin1_character),
+     _f_ =  /*<<uchar.ml:21:80>>*/ Stdlib[28].call(null, cst_U, _e_);
+     /*<<uchar.ml:51:48>>*/ return Stdlib[1].call(null, _f_) /*<<uchar.ml:52:19>>*/ ;
    }
    function unsafe_to_char(_e_){ /*<<?>>*/ return _e_;}
    function equal(_e_, _d_){return _e_ === _d_ ? 1 : 0;}
@@ -3210,23 +3176,23 @@
     /*<<list.ml:27:19>>*/ }
    function hd(param){
      /*<<list.ml:29:9>>*/ if(! param)
-      /*<<list.ml:30:10>>*/ return caml_call1(Stdlib[2], cst_hd) /*<<list.ml:31:13>>*/ ;
+      /*<<list.ml:30:10>>*/ return Stdlib[2].call(null, cst_hd) /*<<list.ml:31:13>>*/ ;
     var a =  /*<<list.ml:29:9>>*/ 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 caml_call1(Stdlib[2], cst_tl) /*<<list.ml:35:13>>*/ ;
+      /*<<list.ml:34:10>>*/ return Stdlib[2].call(null, cst_tl) /*<<list.ml:35:13>>*/ ;
     var l =  /*<<list.ml:33:9>>*/ 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 caml_call1(Stdlib[1], cst_List_nth) /*<<list.ml:43:16>>*/ ;
+      /*<<list.ml:38:16>>*/ return Stdlib[1].call(null, cst_List_nth) /*<<list.ml:43:16>>*/ ;
     var l$0 =  /*<<list.ml:38:2>>*/ l, n$0 = n;
     for(;;){
       /*<<list.ml:40:4>>*/ if(! l$0)
-       /*<<list.ml:41:12>>*/ return caml_call1(Stdlib[2], cst_nth) /*<<list.ml:43:16>>*/ ;
+       /*<<list.ml:41:12>>*/ return Stdlib[2].call(null, cst_nth) /*<<list.ml:43:16>>*/ ;
      var l$1 =  /*<<list.ml:40:4>>*/ l$0[2], a = l$0[1];
       /*<<list.ml:42:14>>*/ if(0 === n$0)  /*<<list.ml:42:28>>*/ return a;
      var n$1 =  /*<<list.ml:42:35>>*/ n$0 - 1 | 0;
@@ -3236,7 +3202,7 @@
     /*<<list.ml:43:16>>*/ }
    function nth_opt(l, n){
      /*<<list.ml:46:2>>*/ if(0 > n)
-      /*<<list.ml:46:16>>*/ return caml_call1(Stdlib[1], cst_List_nth$0) /*<<list.ml:51:16>>*/ ;
+      /*<<list.ml:46:16>>*/ return Stdlib[1].call(null, cst_List_nth$0) /*<<list.ml:51:16>>*/ ;
     var l$0 =  /*<<list.ml:46:2>>*/ l, n$0 = n;
     for(;;){
       /*<<list.ml:48:4>>*/ if(! l$0)  /*<<list.ml:49:12>>*/ return 0;
@@ -3280,7 +3246,7 @@
    }
    function init(len, f){
      /*<<list.ml:71:2>>*/ if(0 > len)
-      /*<<list.ml:71:18>>*/ return caml_call1(Stdlib[1], cst_List_init) /*<<list.ml:72:20>>*/ ;
+      /*<<list.ml:71:18>>*/ return Stdlib[1].call(null, cst_List_init) /*<<list.ml:72:20>>*/ ;
     var last =  /*<<list.ml:72:2>>*/ len - 1 | 0, i$1 = 0;
      /*<<list.ml:63:2>>*/ if(last < 0)  /*<<list.ml:63:19>>*/ return 0;
      /*<<list.ml:64:7>>*/ if(0 === last)
@@ -3319,7 +3285,7 @@
      r =  /*<<list.ml:74:18>>*/ param[2],
      l = param[1],
      _f_ =  /*<<list.ml:76:16>>*/ flatten(r);
-     /*<<list.ml:76:25>>*/ return caml_call2(Stdlib[37], l, _f_);
+     /*<<list.ml:76:25>>*/ return Stdlib[37].call(null, l, _f_);
    }
    function map(f, param){
      /*<<list.ml:80:28>>*/ if(! param)  /*<<list.ml:81:10>>*/ return 0;
@@ -3515,7 +3481,7 @@
            break a;
           }
            /*<<list.ml:140:14>>*/ dst[offset + 1] =
-           caml_call1(Stdlib[1], cst_List_map2$0);
+           Stdlib[1].call(null, cst_List_map2$0);
          }
           /*<<list.ml:139:26>>*/ return [0, r1, block];
         }
@@ -3530,7 +3496,7 @@
      }
     }
     else if(! l2)  /*<<list.ml:132:16>>*/ return 0;
-     /*<<list.ml:140:14>>*/ return caml_call1(Stdlib[1], cst_List_map2) /*<<list.ml:140:37>>*/ ;
+     /*<<list.ml:140:14>>*/ return Stdlib[1].call(null, cst_List_map2) /*<<list.ml:140:37>>*/ ;
    }
    function rev_map2(f, l1, l2){
     var accu =  /*<<list.ml:149:2>>*/ 0, l1$0 = l1, l2$0 = l2;
@@ -3550,7 +3516,7 @@
       }
      }
      else if(! l2$0)  /*<<list.ml:145:18>>*/ return accu;
-      /*<<list.ml:147:16>>*/ return caml_call1(Stdlib[1], cst_List_rev_map2) /*<<list.ml:149:18>>*/ ;
+      /*<<list.ml:147:16>>*/ return Stdlib[1].call(null, cst_List_rev_map2) /*<<list.ml:149:18>>*/ ;
     }
    }
    function iter2(f, l1$1, l2$1){
@@ -3566,7 +3532,7 @@
       }
      }
      else if(! l2)  /*<<list.ml:154:16>>*/ return 0;
-      /*<<list.ml:156:14>>*/ return caml_call1(Stdlib[1], cst_List_iter2) /*<<list.ml:156:38>>*/ ;
+      /*<<list.ml:156:14>>*/ return Stdlib[1].call(null, cst_List_iter2) /*<<list.ml:156:38>>*/ ;
     }
    }
    function fold_left2(f, accu$1, l1$1, l2$1){
@@ -3587,7 +3553,7 @@
       }
      }
      else if(! l2)  /*<<list.ml:160:16>>*/ return accu;
-      /*<<list.ml:162:14>>*/ return caml_call1(Stdlib[1], cst_List_fold_left2) /*<<list.ml:162:43>>*/ ;
+      /*<<list.ml:162:14>>*/ return Stdlib[1].call(null, cst_List_fold_left2) /*<<list.ml:162:43>>*/ ;
     }
    }
    function fold_right2(f, l1, l2, accu){
@@ -3602,7 +3568,7 @@
      }
     }
     else if(! l2)  /*<<list.ml:166:16>>*/ return accu;
-     /*<<list.ml:168:14>>*/ return caml_call1(Stdlib[1], cst_List_fold_right2) /*<<list.ml:168:44>>*/ ;
+     /*<<list.ml:168:14>>*/ return Stdlib[1].call(null, cst_List_fold_right2) /*<<list.ml:168:44>>*/ ;
    }
    function for_all(p, param$0){
     var param =  /*<<list.ml:170:16>>*/ param$0;
@@ -3646,7 +3612,7 @@
       }
      }
      else if(! l2)  /*<<list.ml:180:16>>*/ return 1;
-      /*<<list.ml:182:14>>*/ return caml_call1(Stdlib[1], cst_List_for_all2) /*<<list.ml:182:41>>*/ ;
+      /*<<list.ml:182:14>>*/ return Stdlib[1].call(null, cst_List_for_all2) /*<<list.ml:182:41>>*/ ;
     }
    }
    function exists2(p, l1$1, l2$1){
@@ -3667,7 +3633,7 @@
       }
      }
      else if(! l2)  /*<<list.ml:186:16>>*/ return 0;
-      /*<<list.ml:188:14>>*/ return caml_call1(Stdlib[1], cst_List_exists2) /*<<list.ml:188:40>>*/ ;
+      /*<<list.ml:188:14>>*/ return Stdlib[1].call(null, cst_List_exists2) /*<<list.ml:188:40>>*/ ;
     }
    }
    function mem(x, param$0){
@@ -4012,7 +3978,7 @@
     /*<<list.ml:286:42>>*/ }
    function take(n, l){
      /*<<list.ml:298:2>>*/ if(n < 0)
-      /*<<list.ml:298:16>>*/ caml_call1(Stdlib[1], cst_List_take);
+      /*<<list.ml:298:16>>*/ Stdlib[1].call(null, cst_List_take);
      /*<<list.ml:294:4>>*/ if(0 !== n && l){
      var
       l$0 = l[2],
@@ -4045,7 +4011,7 @@
     /*<<list.ml:299:9>>*/ }
    function drop(n, rest){
      /*<<list.ml:306:2>>*/ if(n < 0)
-      /*<<list.ml:306:16>>*/ caml_call1(Stdlib[1], cst_List_drop);
+      /*<<list.ml:306:16>>*/ Stdlib[1].call(null, cst_List_drop);
     var i =  /*<<list.ml:307:2>>*/ 0, rest$0 = rest;
     for(;;){
       /*<<list.ml:302:14>>*/ if(rest$0){
@@ -4183,7 +4149,7 @@
      }
     }
     else if(! l2)  /*<<list.ml:352:16>>*/ return 0;
-     /*<<list.ml:354:14>>*/ return caml_call1(Stdlib[1], cst_List_combine) /*<<list.ml:354:40>>*/ ;
+     /*<<list.ml:354:14>>*/ return Stdlib[1].call(null, cst_List_combine) /*<<list.ml:354:40>>*/ ;
    }
    function merge(cmp, l1, l2){
      /*<<list.ml:359:2>>*/ if(! l1)  /*<<list.ml:360:14>>*/ return l2;
@@ -4958,8 +4924,8 @@
       /*<<bytes.ml:69:4>>*/ caml_blit_bytes(s, ofs, r, 0, len);
       /*<<bytes.ml:69:29>>*/ return r;
     }
-     /*<<bytes.ml:66:7>>*/ return caml_call1
-            (Stdlib[1], cst_String_sub_Bytes_sub) /*<<bytes.ml:71:5>>*/ ;
+     /*<<bytes.ml:66:7>>*/ return Stdlib[1].call
+            (null, cst_String_sub_Bytes_sub) /*<<bytes.ml:71:5>>*/ ;
    }
    function sub_string(b, ofs, len){
      /*<<bytes.ml:73:44>>*/ return  /*<<bytes.ml:73:59>>*/ caml_string_of_bytes
@@ -4973,7 +4939,7 @@
     a:
     {
      if(a < 0){if(! _L_ || match) break a;} else if(_L_ || ! match) break a;
-      /*<<bytes.ml:80:27>>*/ return caml_call1(Stdlib[1], cst_Bytes_extend) /*<<bytes.ml:81:10>>*/ ;
+      /*<<bytes.ml:80:27>>*/ return Stdlib[1].call(null, cst_Bytes_extend) /*<<bytes.ml:81:10>>*/ ;
     }
      /*<<bytes.ml:81:9>>*/ return c;
     /*<<bytes.ml:81:10>>*/ }
@@ -4989,8 +4955,8 @@
      var dstoff =  /*<<bytes.ml:86:42>>*/ 0, srcoff = - left | 0;
     var
      cpylen =
-        /*<<bytes.ml:87:2>>*/  /*<<bytes.ml:87:15>>*/ caml_call2
-        (Stdlib_Int[10],
+        /*<<bytes.ml:87:2>>*/  /*<<bytes.ml:87:15>>*/ Stdlib_Int[10].call
+        (null,
           /*<<bytes.ml:87:2>>*/ caml_ml_bytes_length(s) - srcoff | 0,
          len - dstoff | 0);
      /*<<bytes.ml:88:2>>*/ if(0 < cpylen)
@@ -5001,8 +4967,8 @@
      /*<<bytes.ml:92:2>>*/ if
      (0 <= ofs && 0 <= len && (caml_ml_bytes_length(s) - len | 0) >= ofs)
       /*<<bytes.ml:94:7>>*/ return caml_fill_bytes(s, ofs, len, c) /*<<bytes.ml:94:30>>*/ ;
-     /*<<bytes.ml:93:7>>*/ return caml_call1
-            (Stdlib[1], cst_String_fill_Bytes_fill) /*<<bytes.ml:94:30>>*/ ;
+     /*<<bytes.ml:93:7>>*/ return Stdlib[1].call
+            (null, cst_String_fill_Bytes_fill) /*<<bytes.ml:94:30>>*/ ;
    }
    function blit(s1, ofs1, s2, ofs2, len){
      /*<<bytes.ml:97:2>>*/ if
@@ -5013,7 +4979,7 @@
         (caml_ml_bytes_length(s1) - len | 0) >= ofs1
         && 0 <= ofs2 && (caml_ml_bytes_length(s2) - len | 0) >= ofs2)
       /*<<bytes.ml:100:7>>*/ return caml_blit_bytes(s1, ofs1, s2, ofs2, len) /*<<bytes.ml:100:38>>*/ ;
-     /*<<bytes.ml:99:7>>*/ return caml_call1(Stdlib[1], cst_Bytes_blit) /*<<bytes.ml:100:38>>*/ ;
+     /*<<bytes.ml:99:7>>*/ return Stdlib[1].call(null, cst_Bytes_blit) /*<<bytes.ml:100:38>>*/ ;
    }
    function blit_string(s1, ofs1, s2, ofs2, len){
      /*<<bytes.ml:103:2>>*/ if
@@ -5025,8 +4991,8 @@
         && 0 <= ofs2 && (caml_ml_bytes_length(s2) - len | 0) >= ofs2)
       /*<<bytes.ml:106:7>>*/ return runtime.caml_blit_string
              (s1, ofs1, s2, ofs2, len) /*<<bytes.ml:106:45>>*/ ;
-     /*<<bytes.ml:105:7>>*/ return caml_call1
-            (Stdlib[1], cst_String_blit_Bytes_blit_str) /*<<bytes.ml:106:45>>*/ ;
+     /*<<bytes.ml:105:7>>*/ return Stdlib[1].call
+            (null, cst_String_blit_Bytes_blit_str) /*<<bytes.ml:106:45>>*/ ;
    }
    function iter(f, a){
     var
@@ -5079,7 +5045,7 @@
        param = tl;
       }
       else{
-        /*<<bytes.ml:116:48>>*/ acc = caml_call1(Stdlib[1], cst_Bytes_concat);
+        /*<<bytes.ml:116:48>>*/ acc = Stdlib[1].call(null, cst_Bytes_concat);
        param = tl;
       }
      }
@@ -5479,15 +5445,15 @@
     var l =  /*<<bytes.ml:328:2>>*/ caml_ml_bytes_length(s);
      /*<<bytes.ml:329:2>>*/ if(0 <= i && l >= i)
       /*<<bytes.ml:330:2>>*/ return index_rec(s, l, i, c) /*<<bytes.ml:330:19>>*/ ;
-     /*<<bytes.ml:329:25>>*/ return caml_call1
-            (Stdlib[1], cst_String_index_from_Bytes_in) /*<<bytes.ml:330:19>>*/ ;
+     /*<<bytes.ml:329:25>>*/ return Stdlib[1].call
+            (null, cst_String_index_from_Bytes_in) /*<<bytes.ml:330:19>>*/ ;
    }
    function index_from_opt(s, i, c){
     var l =  /*<<bytes.ml:334:2>>*/ caml_ml_bytes_length(s);
      /*<<bytes.ml:335:2>>*/ if(0 <= i && l >= i)
       /*<<bytes.ml:338:4>>*/ return index_rec_opt(s, l, i, c) /*<<bytes.ml:338:25>>*/ ;
-     /*<<bytes.ml:336:4>>*/ return caml_call1
-            (Stdlib[1], cst_String_index_from_opt_Byte) /*<<bytes.ml:338:25>>*/ ;
+     /*<<bytes.ml:336:4>>*/ return Stdlib[1].call
+            (null, cst_String_index_from_opt_Byte) /*<<bytes.ml:338:25>>*/ ;
    }
    function rindex_rec(s, i$1, c){
     var i =  /*<<bytes.ml:342:2>>*/ i$1;
@@ -5507,8 +5473,8 @@
    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:353:20>>*/ ;
-     /*<<bytes.ml:351:4>>*/ return caml_call1
-            (Stdlib[1], cst_String_rindex_from_Bytes_r) /*<<bytes.ml:353:20>>*/ ;
+     /*<<bytes.ml:351:4>>*/ return Stdlib[1].call
+            (null, cst_String_rindex_from_Bytes_r) /*<<bytes.ml:353:20>>*/ ;
    }
    function rindex_rec_opt(s, i$1, c){
     var i =  /*<<bytes.ml:357:2>>*/ i$1;
@@ -5527,8 +5493,8 @@
    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:368:24>>*/ ;
-     /*<<bytes.ml:366:4>>*/ return caml_call1
-            (Stdlib[1], cst_String_rindex_from_opt_Byt) /*<<bytes.ml:368:24>>*/ ;
+     /*<<bytes.ml:366:4>>*/ return Stdlib[1].call
+            (null, cst_String_rindex_from_opt_Byt) /*<<bytes.ml:368:24>>*/ ;
    }
    function contains_from(s, i, c){
     var l =  /*<<bytes.ml:373:2>>*/ caml_ml_bytes_length(s);
@@ -5543,8 +5509,8 @@
       if(exn === Stdlib[8])  /*<<bytes.ml:377:59>>*/ return 0;
        /*<<?>>*/ throw caml_maybe_attach_backtrace(exn, 0);
      }
-     /*<<bytes.ml:375:4>>*/ return caml_call1
-            (Stdlib[1], cst_String_contains_from_Bytes) /*<<bytes.ml:377:64>>*/ ;
+     /*<<bytes.ml:375:4>>*/ return Stdlib[1].call
+            (null, 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>>*/ ;
@@ -5561,8 +5527,8 @@
       if(exn === Stdlib[8])  /*<<bytes.ml:388:58>>*/ return 0;
        /*<<?>>*/ throw caml_maybe_attach_backtrace(exn, 0);
      }
-     /*<<bytes.ml:386:4>>*/ return caml_call1
-            (Stdlib[1], cst_String_rcontains_from_Byte) /*<<bytes.ml:388:63>>*/ ;
+     /*<<bytes.ml:386:4>>*/ return Stdlib[1].call
+            (null, cst_String_rcontains_from_Byte) /*<<bytes.ml:388:63>>*/ ;
    }
    var
     compare =  /*<<bytes.ml:53:20>>*/ runtime.caml_bytes_compare,
@@ -5622,19 +5588,19 @@
     var
      n =  /*<<bytes.ml:429:2>>*/ [0, 0],
      buf =  /*<<bytes.ml:430:16>>*/ [0, make(256, 0)];
-     /*<<bytes.ml:439:2>>*/ caml_call2
-     (Stdlib_Seq[4],
+     /*<<bytes.ml:439:2>>*/ Stdlib_Seq[4].call
+     (null,
       function(c){
         /*<<bytes.ml:441:7>>*/ if(n[1] === caml_ml_bytes_length(buf[1])){
         var
          new_len =
-            /*<<bytes.ml:433:4>>*/  /*<<bytes.ml:433:18>>*/ caml_call2
-            (Stdlib_Int[10],
+            /*<<bytes.ml:433:4>>*/  /*<<bytes.ml:433:18>>*/ Stdlib_Int[10].call
+            (null,
              2 *  /*<<bytes.ml:433:4>>*/ caml_ml_bytes_length(buf[1]) | 0,
              Stdlib_Sys[12]);
          /*<<bytes.ml:434:4>>*/ if(caml_ml_bytes_length(buf[1]) === new_len)
-          /*<<bytes.ml:434:34>>*/ caml_call1
-          (Stdlib[2], cst_Bytes_of_seq_cannot_grow_b);
+          /*<<bytes.ml:434:34>>*/ Stdlib[2].call
+          (null, cst_Bytes_of_seq_cannot_grow_b);
         var new_buf =  /*<<bytes.ml:435:18>>*/ make(new_len, 0);
          /*<<bytes.ml:436:4>>*/ blit(buf[1], 0, new_buf, 0, n[1]);
          /*<<bytes.ml:436:28>>*/ buf[1] = new_buf;
@@ -5781,8 +5747,8 @@
     _e_ = [0, cst_bytes_ml, 831, 9],
     _f_ = [0, cst_bytes_ml, 820, 20];
    function dec_ret(n, u){
-    var _i_ =  /*<<bytes.ml:557:46>>*/ caml_call1(Stdlib_Uchar[9], u);
-     /*<<bytes.ml:557:69>>*/ return caml_call2(Stdlib_Uchar[22], n, _i_);
+    var _i_ =  /*<<bytes.ml:557:46>>*/ Stdlib_Uchar[9].call(null, u);
+     /*<<bytes.ml:557:69>>*/ return Stdlib_Uchar[22].call(null, n, _i_);
    }
    function not_in_x80_to_xBF(b){
      /*<<bytes.ml:575:35>>*/ return 2 !== (b >>> 6 | 0) ? 1 : 0;
@@ -5823,59 +5789,59 @@
          case 0:
           var i$0 =  /*<<bytes.ml:619:6>>*/ i + 1 | 0;
            /*<<bytes.ml:619:23>>*/ if(max < i$0)
-            /*<<bytes.ml:619:39>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:619:39>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
           var b1$4 =  /*<<bytes.ml:619:23>>*/ caml_bytes_unsafe_get(b, i$0);
            /*<<bytes.ml:620:29>>*/ if(not_in_x80_to_x9F(b1$4))
-            /*<<bytes.ml:620:55>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:620:55>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
           var i$1 =  /*<<bytes.ml:621:6>>*/ i$0 + 1 | 0;
            /*<<bytes.ml:621:23>>*/ if(max < i$1)
-            /*<<bytes.ml:621:39>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:621:39>>*/ return dec_invalid(2) /*<<bytes.ml:648:22>>*/ ;
           var b2$3 =  /*<<bytes.ml:621:23>>*/ caml_bytes_unsafe_get(b, i$1);
            /*<<bytes.ml:622:29>>*/ return not_in_x80_to_xBF(b2$3)
-                  ?  /*<<bytes.ml:622:55>>*/ caml_call1(dec_invalid, 2)
+                  ?  /*<<bytes.ml:622:55>>*/ dec_invalid(2)
                   :  /*<<bytes.ml:623:40>>*/ dec_ret
                     (3,  /*<<bytes.ml:623:16>>*/ utf_8_uchar_3(b0, b1$4, b2$3)) /*<<bytes.ml:648:22>>*/ ;
          case 3:
           var i$4 =  /*<<bytes.ml:625:6>>*/ i + 1 | 0;
            /*<<bytes.ml:625:23>>*/ if(max < i$4)
-            /*<<bytes.ml:625:39>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:625:39>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
           var b1$2 =  /*<<bytes.ml:625:23>>*/ caml_bytes_unsafe_get(b, i$4);
            /*<<bytes.ml:626:29>>*/ if(not_in_x90_to_xBF(b1$2))
-            /*<<bytes.ml:626:55>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:626:55>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
           var i$5 =  /*<<bytes.ml:627:6>>*/ i$4 + 1 | 0;
            /*<<bytes.ml:627:23>>*/ if(max < i$5)
-            /*<<bytes.ml:627:39>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:627:39>>*/ return dec_invalid(2) /*<<bytes.ml:648:22>>*/ ;
           var b2$1 =  /*<<bytes.ml:627:23>>*/ caml_bytes_unsafe_get(b, i$5);
            /*<<bytes.ml:628:29>>*/ if(not_in_x80_to_xBF(b2$1))
-            /*<<bytes.ml:628:55>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:628:55>>*/ return dec_invalid(2) /*<<bytes.ml:648:22>>*/ ;
           var i$6 =  /*<<bytes.ml:629:6>>*/ i$5 + 1 | 0;
            /*<<bytes.ml:629:23>>*/ if(max < i$6)
-            /*<<bytes.ml:629:39>>*/ return caml_call1(dec_invalid, 3) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:629:39>>*/ return dec_invalid(3) /*<<bytes.ml:648:22>>*/ ;
           var b3$1 =  /*<<bytes.ml:629:23>>*/ caml_bytes_unsafe_get(b, i$6);
            /*<<bytes.ml:630:29>>*/ return not_in_x80_to_xBF(b3$1)
-                  ?  /*<<bytes.ml:630:55>>*/ caml_call1(dec_invalid, 3)
+                  ?  /*<<bytes.ml:630:55>>*/ dec_invalid(3)
                   :  /*<<bytes.ml:631:43>>*/ dec_ret
                     (4,
                       /*<<bytes.ml:631:16>>*/ utf_8_uchar_4(b0, b1$2, b2$1, b3$1)) /*<<bytes.ml:648:22>>*/ ;
          case 7:
           var i$10 =  /*<<bytes.ml:641:6>>*/ i + 1 | 0;
            /*<<bytes.ml:641:23>>*/ if(max < i$10)
-            /*<<bytes.ml:641:39>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:641:39>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
           var b1$0 =  /*<<bytes.ml:641:23>>*/ caml_bytes_unsafe_get(b, i$10);
            /*<<bytes.ml:642:29>>*/ if(not_in_x80_to_x8F(b1$0))
-            /*<<bytes.ml:642:55>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:642:55>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
           var i$11 =  /*<<bytes.ml:643:6>>*/ i$10 + 1 | 0;
            /*<<bytes.ml:643:23>>*/ if(max < i$11)
-            /*<<bytes.ml:643:39>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:643:39>>*/ return dec_invalid(2) /*<<bytes.ml:648:22>>*/ ;
           var b2 =  /*<<bytes.ml:643:23>>*/ caml_bytes_unsafe_get(b, i$11);
            /*<<bytes.ml:644:29>>*/ if(not_in_x80_to_xBF(b2))
-            /*<<bytes.ml:644:55>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:644:55>>*/ return dec_invalid(2) /*<<bytes.ml:648:22>>*/ ;
           var i$12 =  /*<<bytes.ml:645:6>>*/ i$11 + 1 | 0;
            /*<<bytes.ml:645:23>>*/ if(max < i$12)
-            /*<<bytes.ml:645:39>>*/ return caml_call1(dec_invalid, 3) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:645:39>>*/ return dec_invalid(3) /*<<bytes.ml:648:22>>*/ ;
           var b3 =  /*<<bytes.ml:645:23>>*/ caml_bytes_unsafe_get(b, i$12);
            /*<<bytes.ml:646:29>>*/ return not_in_x80_to_xBF(b3)
-                  ?  /*<<bytes.ml:646:55>>*/ caml_call1(dec_invalid, 3)
+                  ?  /*<<bytes.ml:646:55>>*/ dec_invalid(3)
                   :  /*<<bytes.ml:647:43>>*/ dec_ret
                     (4,
                       /*<<bytes.ml:647:16>>*/ utf_8_uchar_4(b0, b1$0, b2, b3)) /*<<bytes.ml:648:22>>*/ ;
@@ -5884,22 +5850,22 @@
          default:
           var i$7 =  /*<<bytes.ml:633:6>>*/ i + 1 | 0;
            /*<<bytes.ml:633:23>>*/ if(max < i$7)
-            /*<<bytes.ml:633:39>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:633:39>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
           var b1$1 =  /*<<bytes.ml:633:23>>*/ caml_bytes_unsafe_get(b, i$7);
            /*<<bytes.ml:634:29>>*/ if(not_in_x80_to_xBF(b1$1))
-            /*<<bytes.ml:634:55>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:634:55>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
           var i$8 =  /*<<bytes.ml:635:6>>*/ i$7 + 1 | 0;
            /*<<bytes.ml:635:23>>*/ if(max < i$8)
-            /*<<bytes.ml:635:39>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:635:39>>*/ return dec_invalid(2) /*<<bytes.ml:648:22>>*/ ;
           var b2$0 =  /*<<bytes.ml:635:23>>*/ caml_bytes_unsafe_get(b, i$8);
            /*<<bytes.ml:636:29>>*/ if(not_in_x80_to_xBF(b2$0))
-            /*<<bytes.ml:636:55>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:636:55>>*/ return dec_invalid(2) /*<<bytes.ml:648:22>>*/ ;
           var i$9 =  /*<<bytes.ml:637:6>>*/ i$8 + 1 | 0;
            /*<<bytes.ml:637:23>>*/ if(max < i$9)
-            /*<<bytes.ml:637:39>>*/ return caml_call1(dec_invalid, 3) /*<<bytes.ml:648:22>>*/ ;
+            /*<<bytes.ml:637:39>>*/ return dec_invalid(3) /*<<bytes.ml:648:22>>*/ ;
           var b3$0 =  /*<<bytes.ml:637:23>>*/ 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)
+                  ?  /*<<bytes.ml:638:55>>*/ dec_invalid(3)
                   :  /*<<bytes.ml:639:43>>*/ dec_ret
                     (4,
                       /*<<bytes.ml:639:16>>*/ utf_8_uchar_4(b0, b1$1, b2$0, b3$0)) /*<<bytes.ml:648:22>>*/ ;
@@ -5908,31 +5874,31 @@
       else if(225 > b0){
        var i$13 =  /*<<bytes.ml:607:6>>*/ i + 1 | 0;
         /*<<bytes.ml:607:23>>*/ if(max < i$13)
-         /*<<bytes.ml:607:39>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+         /*<<bytes.ml:607:39>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
        var b1$5 =  /*<<bytes.ml:607:23>>*/ caml_bytes_unsafe_get(b, i$13);
         /*<<bytes.ml:608:29>>*/ if(not_in_xA0_to_xBF(b1$5))
-         /*<<bytes.ml:608:55>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+         /*<<bytes.ml:608:55>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
        var i$14 =  /*<<bytes.ml:609:6>>*/ i$13 + 1 | 0;
         /*<<bytes.ml:609:23>>*/ if(max < i$14)
-         /*<<bytes.ml:609:39>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:648:22>>*/ ;
+         /*<<bytes.ml:609:39>>*/ return dec_invalid(2) /*<<bytes.ml:648:22>>*/ ;
        var b2$4 =  /*<<bytes.ml:609:23>>*/ 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)
+               ?  /*<<bytes.ml:610:55>>*/ dec_invalid(2)
                :  /*<<bytes.ml:611:40>>*/ dec_ret
                  (3,  /*<<bytes.ml:611:16>>*/ utf_8_uchar_3(b0, b1$5, b2$4)) /*<<bytes.ml:648:22>>*/ ;
       }
       var i$2 =  /*<<bytes.ml:613:6>>*/ i + 1 | 0;
        /*<<bytes.ml:613:23>>*/ if(max < i$2)
-        /*<<bytes.ml:613:39>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+        /*<<bytes.ml:613:39>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
       var b1$3 =  /*<<bytes.ml:613:23>>*/ caml_bytes_unsafe_get(b, i$2);
        /*<<bytes.ml:614:29>>*/ if(not_in_x80_to_xBF(b1$3))
-        /*<<bytes.ml:614:55>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+        /*<<bytes.ml:614:55>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
       var i$3 =  /*<<bytes.ml:615:6>>*/ i$2 + 1 | 0;
        /*<<bytes.ml:615:23>>*/ if(max < i$3)
-        /*<<bytes.ml:615:39>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:648:22>>*/ ;
+        /*<<bytes.ml:615:39>>*/ return dec_invalid(2) /*<<bytes.ml:648:22>>*/ ;
       var b2$2 =  /*<<bytes.ml:615:23>>*/ caml_bytes_unsafe_get(b, i$3);
        /*<<bytes.ml:616:29>>*/ return not_in_x80_to_xBF(b2$2)
-              ?  /*<<bytes.ml:616:55>>*/ caml_call1(dec_invalid, 2)
+              ?  /*<<bytes.ml:616:55>>*/ dec_invalid(2)
               :  /*<<bytes.ml:617:40>>*/ dec_ret
                 (3,  /*<<bytes.ml:617:16>>*/ utf_8_uchar_3(b0, b1$3, b2$2)) /*<<bytes.ml:648:22>>*/ ;
      }
@@ -5941,14 +5907,14 @@
       /*<<bytes.ml:600:2>>*/ if(194 <= b0){
       var i$15 =  /*<<bytes.ml:603:6>>*/ i + 1 | 0;
        /*<<bytes.ml:603:23>>*/ if(max < i$15)
-        /*<<bytes.ml:603:39>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+        /*<<bytes.ml:603:39>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
       var b1 =  /*<<bytes.ml:603:23>>*/ caml_bytes_unsafe_get(b, i$15);
        /*<<bytes.ml:604:29>>*/ return not_in_x80_to_xBF(b1)
-              ?  /*<<bytes.ml:604:55>>*/ caml_call1(dec_invalid, 1)
+              ?  /*<<bytes.ml:604:55>>*/ dec_invalid(1)
               :  /*<<bytes.ml:605:37>>*/ dec_ret(2, (b0 & 31) << 6 | b1 & 63) /*<<bytes.ml:648:22>>*/ ;
      }
     }
-     /*<<bytes.ml:648:9>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:648:22>>*/ ;
+     /*<<bytes.ml:648:9>>*/ return dec_invalid(1) /*<<bytes.ml:648:22>>*/ ;
    }
    function set_utf_8_uchar(b, i, u){
     function set(_h_, _g_, _f_){
@@ -5956,7 +5922,7 @@
     }
     var
      max =  /*<<bytes.ml:652:2>>*/ caml_ml_bytes_length(b) - 1 | 0,
-     u$0 =  /*<<bytes.ml:653:8>>*/ caml_call1(Stdlib_Uchar[10], u);
+     u$0 =  /*<<bytes.ml:653:8>>*/ Stdlib_Uchar[10].call(null, u);
      /*<<bytes.ml:654:11>>*/ if(0 > u$0)
       /*<<bytes.ml:654:20>>*/ throw caml_maybe_attach_backtrace
             ([0, Assert_failure, _b_], 1);
@@ -6156,15 +6122,14 @@
     var max =  /*<<bytes.ml:746:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
      /*<<bytes.ml:747:2>>*/ if(0 <= i && max >= i){
       /*<<bytes.ml:748:2>>*/ if(i === max)
-       /*<<bytes.ml:748:18>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:759:21>>*/ ;
+       /*<<bytes.ml:748:18>>*/ return dec_invalid(1) /*<<bytes.ml:759:21>>*/ ;
      var hi =  /*<<bytes.ml:749:8>>*/ unsafe_get_uint16_be(b, i);
       /*<<bytes.ml:750:11>>*/ if(55296 <= hi && 57343 >= hi){
        /*<<bytes.ml:751:11>>*/ if(56319 < hi)
-        /*<<bytes.ml:751:25>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:759:21>>*/ ;
+        /*<<bytes.ml:751:25>>*/ return dec_invalid(2) /*<<bytes.ml:759:21>>*/ ;
       var last =  /*<<bytes.ml:753:6>>*/ i + 3 | 0;
        /*<<bytes.ml:754:6>>*/ if(max < last)
-        /*<<bytes.ml:754:25>>*/ return caml_call1
-               (dec_invalid, (max - i | 0) + 1 | 0) /*<<bytes.ml:759:21>>*/ ;
+        /*<<bytes.ml:754:25>>*/ return dec_invalid((max - i | 0) + 1 | 0) /*<<bytes.ml:759:21>>*/ ;
       var lo =  /*<<bytes.ml:755:12>>*/ unsafe_get_uint16_be(b, i + 2 | 0);
        /*<<bytes.ml:756:15>>*/ if(56320 <= lo && 57343 >= lo){
        var
@@ -6172,17 +6137,17 @@
            /*<<bytes.ml:758:10>>*/ ((hi & 1023) << 10 | lo & 1023) + 65536 | 0;
         /*<<bytes.ml:759:10>>*/ return dec_ret(4, u) /*<<bytes.ml:759:21>>*/ ;
       }
-       /*<<bytes.ml:756:43>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:759:21>>*/ ;
+       /*<<bytes.ml:756:43>>*/ return dec_invalid(2) /*<<bytes.ml:759:21>>*/ ;
      }
       /*<<bytes.ml:750:39>>*/ return dec_ret(2, hi) /*<<bytes.ml:759:21>>*/ ;
     }
-     /*<<bytes.ml:747:27>>*/ return caml_call1
-            (Stdlib[1], cst_index_out_of_bounds) /*<<bytes.ml:759:21>>*/ ;
+     /*<<bytes.ml:747:27>>*/ return Stdlib[1].call
+            (null, cst_index_out_of_bounds) /*<<bytes.ml:759:21>>*/ ;
    }
    function set_utf_16be_uchar(b, i, u){
     var max =  /*<<bytes.ml:763:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
      /*<<bytes.ml:764:2>>*/ if(0 <= i && max >= i){
-     var u$0 =  /*<<bytes.ml:765:8>>*/ caml_call1(Stdlib_Uchar[10], u);
+     var u$0 =  /*<<bytes.ml:765:8>>*/ Stdlib_Uchar[10].call(null, u);
       /*<<bytes.ml:766:11>>*/ if(0 > u$0)
        /*<<bytes.ml:766:20>>*/ throw caml_maybe_attach_backtrace
              ([0, Assert_failure, _d_], 1);
@@ -6205,8 +6170,8 @@
       /*<<bytes.ml:776:18>>*/ unsafe_set_uint16_be(b, i + 2 | 0, lo);
       /*<<bytes.ml:776:34>>*/ return 4;
     }
-     /*<<bytes.ml:764:27>>*/ return caml_call1
-            (Stdlib[1], cst_index_out_of_bounds$0) /*<<bytes.ml:777:21>>*/ ;
+     /*<<bytes.ml:764:27>>*/ return Stdlib[1].call
+            (null, cst_index_out_of_bounds$0) /*<<bytes.ml:777:21>>*/ ;
    }
    function is_valid_utf_16be(b){
     var max =  /*<<bytes.ml:794:2>>*/ caml_ml_bytes_length(b) - 1 | 0, i = 0;
@@ -6236,15 +6201,14 @@
     var max =  /*<<bytes.ml:800:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
      /*<<bytes.ml:801:2>>*/ if(0 <= i && max >= i){
       /*<<bytes.ml:802:2>>*/ if(i === max)
-       /*<<bytes.ml:802:18>>*/ return caml_call1(dec_invalid, 1) /*<<bytes.ml:813:21>>*/ ;
+       /*<<bytes.ml:802:18>>*/ return dec_invalid(1) /*<<bytes.ml:813:21>>*/ ;
      var hi =  /*<<bytes.ml:803:8>>*/ unsafe_get_uint16_le(b, i);
       /*<<bytes.ml:804:11>>*/ if(55296 <= hi && 57343 >= hi){
        /*<<bytes.ml:805:11>>*/ if(56319 < hi)
-        /*<<bytes.ml:805:25>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:813:21>>*/ ;
+        /*<<bytes.ml:805:25>>*/ return dec_invalid(2) /*<<bytes.ml:813:21>>*/ ;
       var last =  /*<<bytes.ml:807:6>>*/ i + 3 | 0;
        /*<<bytes.ml:808:6>>*/ if(max < last)
-        /*<<bytes.ml:808:25>>*/ return caml_call1
-               (dec_invalid, (max - i | 0) + 1 | 0) /*<<bytes.ml:813:21>>*/ ;
+        /*<<bytes.ml:808:25>>*/ return dec_invalid((max - i | 0) + 1 | 0) /*<<bytes.ml:813:21>>*/ ;
       var lo =  /*<<bytes.ml:809:12>>*/ unsafe_get_uint16_le(b, i + 2 | 0);
        /*<<bytes.ml:810:15>>*/ if(56320 <= lo && 57343 >= lo){
        var
@@ -6252,17 +6216,17 @@
            /*<<bytes.ml:812:10>>*/ ((hi & 1023) << 10 | lo & 1023) + 65536 | 0;
         /*<<bytes.ml:813:10>>*/ return dec_ret(4, u) /*<<bytes.ml:813:21>>*/ ;
       }
-       /*<<bytes.ml:810:43>>*/ return caml_call1(dec_invalid, 2) /*<<bytes.ml:813:21>>*/ ;
+       /*<<bytes.ml:810:43>>*/ return dec_invalid(2) /*<<bytes.ml:813:21>>*/ ;
      }
       /*<<bytes.ml:804:39>>*/ return dec_ret(2, hi) /*<<bytes.ml:813:21>>*/ ;
     }
-     /*<<bytes.ml:801:27>>*/ return caml_call1
-            (Stdlib[1], cst_index_out_of_bounds$1) /*<<bytes.ml:813:21>>*/ ;
+     /*<<bytes.ml:801:27>>*/ return Stdlib[1].call
+            (null, cst_index_out_of_bounds$1) /*<<bytes.ml:813:21>>*/ ;
    }
    function set_utf_16le_uchar(b, i, u){
     var max =  /*<<bytes.ml:817:2>>*/ caml_ml_bytes_length(b) - 1 | 0;
      /*<<bytes.ml:818:2>>*/ if(0 <= i && max >= i){
-     var u$0 =  /*<<bytes.ml:819:8>>*/ caml_call1(Stdlib_Uchar[10], u);
+     var u$0 =  /*<<bytes.ml:819:8>>*/ Stdlib_Uchar[10].call(null, u);
       /*<<bytes.ml:820:11>>*/ if(0 > u$0)
        /*<<bytes.ml:820:20>>*/ throw caml_maybe_attach_backtrace
              ([0, Assert_failure, _f_], 1);
@@ -6285,8 +6249,8 @@
       /*<<bytes.ml:830:18>>*/ unsafe_set_uint16_le(b, i + 2 | 0, lo);
       /*<<bytes.ml:830:34>>*/ return 4;
     }
-     /*<<bytes.ml:818:27>>*/ return caml_call1
-            (Stdlib[1], cst_index_out_of_bounds$2) /*<<bytes.ml:831:21>>*/ ;
+     /*<<bytes.ml:818:27>>*/ return Stdlib[1].call
+            (null, cst_index_out_of_bounds$2) /*<<bytes.ml:831:21>>*/ ;
    }
    function is_valid_utf_16le(b){
     var max =  /*<<bytes.ml:848:2>>*/ caml_ml_bytes_length(b) - 1 | 0, i = 0;
@@ -6409,7 +6373,7 @@
 
 //# unitInfo: Provides: Stdlib__String
 //# unitInfo: Requires: Stdlib, Stdlib__Bytes
-//# shape: Stdlib__String:[F(2),F(2),N,F(1),F(1),F(5),F(2),F(2)*,F(2)*,F(2)*,F(2),F(2),F(3),F(3),F(2),F(3),F(2),F(2),F(2),F(3),F(3),F(2),F(2),F(1),F(1),F(1),F(1),F(1),F(1),F(2),F(2),F(3),F(3),F(3),F(3),F(2),F(2),F(2),F(2),F(1),F(1),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2)]
+//# shape: Stdlib__String:[F(2),F(2),N,F(1),F(1),F(5),F(2),F(2)*,F(2)*,F(2)*,F(2),F(2),F(3),F(3),F(2),F(3),F(2),F(2),F(2),F(3),F(3),F(2),F(2),F(1),F(1),F(1),F(1),F(1),F(1),F(2),F(2),F(3),F(3),F(3),F(3),F(2),F(2),F(2),F(2),F(1)*,F(1)*,F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -6433,11 +6397,6 @@
             ? 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,
@@ -6447,20 +6406,18 @@
     bts = Stdlib_Bytes[44],
     bos = Stdlib_Bytes[45];
    function make(n, c){
-     /*<<string.ml:36:2>>*/ return  /*<<string.ml:36:12>>*/ caml_call1
-            (bts,  /*<<string.ml:36:2>>*/ caml_call2(Stdlib_Bytes[1], n, c)) /*<<string.ml:36:19>>*/ ;
+     /*<<string.ml:36:2>>*/ return  /*<<string.ml:36:12>>*/ bts
+            ( /*<<string.ml:36:2>>*/ Stdlib_Bytes[1].call(null, n, c)) /*<<string.ml:36:19>>*/ ;
    }
    function init(n, f){
-     /*<<string.ml:38:2>>*/ return  /*<<string.ml:38:12>>*/ caml_call1
-            (bts,  /*<<string.ml:38:2>>*/ caml_call2(Stdlib_Bytes[2], n, f)) /*<<string.ml:38:19>>*/ ;
+     /*<<string.ml:38:2>>*/ return  /*<<string.ml:38:12>>*/ bts
+            ( /*<<string.ml:38:2>>*/ Stdlib_Bytes[2].call(null, n, f)) /*<<string.ml:38:19>>*/ ;
    }
    var of_bytes =  /*<<?>>*/ Stdlib_Bytes[6], to_bytes = Stdlib_Bytes[5];
    function sub(s, ofs, len){
-    var _h_ =  /*<<string.ml:43:8>>*/ caml_call1(bos, s);
-     /*<<string.ml:43:2>>*/ return  /*<<string.ml:43:23>>*/ caml_call1
-            (bts,
-              /*<<string.ml:43:2>>*/ caml_call3
-              (Stdlib_Bytes[7], _h_, ofs, len)) /*<<string.ml:43:30>>*/ ;
+    var _h_ =  /*<<string.ml:43:8>>*/ bos(s);
+     /*<<string.ml:43:2>>*/ return  /*<<string.ml:43:23>>*/ bts
+            ( /*<<string.ml:43:2>>*/ Stdlib_Bytes[7].call(null, _h_, ofs, len)) /*<<string.ml:43:30>>*/ ;
    }
    var
     blit =  /*<<?>>*/ Stdlib_Bytes[12],
@@ -6486,7 +6443,7 @@
        param = tl;
       }
       else{
-        /*<<string.ml:47:48>>*/ acc = caml_call1(Stdlib[1], cst_String_concat);
+        /*<<string.ml:47:48>>*/ acc = Stdlib[1].call(null, cst_String_concat);
        param = tl;
       }
      }
@@ -6521,7 +6478,7 @@
        /*<<string.ml:57:4>>*/ caml_blit_string
        (hd$0, 0, dst, pos, caml_ml_string_length(hd$0));
      }
-      /*<<string.ml:68:26>>*/ return caml_call1(bts, dst);
+      /*<<string.ml:68:26>>*/ return bts(dst);
     }
    }
    var
@@ -6567,32 +6524,30 @@
      /*<<string.ml:78:2>>*/ return 0;
     /*<<string.ml:78:56>>*/ }
    function map(f, s){
-    var _d_ =  /*<<string.ml:81:10>>*/ caml_call1(bos, s);
-     /*<<string.ml:81:2>>*/ return  /*<<string.ml:81:17>>*/ caml_call1
-            (bts,
-              /*<<string.ml:81:2>>*/ caml_call2(Stdlib_Bytes[17], f, _d_)) /*<<string.ml:81:24>>*/ ;
+    var _d_ =  /*<<string.ml:81:10>>*/ bos(s);
+     /*<<string.ml:81:2>>*/ return  /*<<string.ml:81:17>>*/ bts
+            ( /*<<string.ml:81:2>>*/ Stdlib_Bytes[17].call(null, f, _d_)) /*<<string.ml:81:24>>*/ ;
    }
    function mapi(f, s){
-    var _d_ =  /*<<string.ml:83:11>>*/ caml_call1(bos, s);
-     /*<<string.ml:83:2>>*/ return  /*<<string.ml:83:18>>*/ caml_call1
-            (bts,
-              /*<<string.ml:83:2>>*/ caml_call2(Stdlib_Bytes[18], f, _d_)) /*<<string.ml:83:25>>*/ ;
+    var _d_ =  /*<<string.ml:83:11>>*/ bos(s);
+     /*<<string.ml:83:2>>*/ return  /*<<string.ml:83:18>>*/ bts
+            ( /*<<string.ml:83:2>>*/ Stdlib_Bytes[18].call(null, f, _d_)) /*<<string.ml:83:25>>*/ ;
    }
    function fold_right(f, x, a){
-    var _d_ =  /*<<string.ml:85:17>>*/ caml_call1(bos, x);
-     /*<<string.ml:85:24>>*/ return caml_call3(Stdlib_Bytes[20], f, _d_, a) /*<<string.ml:85:26>>*/ ;
+    var _d_ =  /*<<string.ml:85:17>>*/ bos(x);
+     /*<<string.ml:85:24>>*/ return Stdlib_Bytes[20].call(null, f, _d_, a) /*<<string.ml:85:26>>*/ ;
    }
    function fold_left(f, a, x){
-    var _d_ =  /*<<string.ml:87:18>>*/ caml_call1(bos, x);
-     /*<<string.ml:87:25>>*/ return caml_call3(Stdlib_Bytes[19], f, a, _d_);
+    var _d_ =  /*<<string.ml:87:18>>*/ bos(x);
+     /*<<string.ml:87:25>>*/ return Stdlib_Bytes[19].call(null, f, a, _d_);
    }
    function exists(f, s){
-    var _d_ =  /*<<string.ml:89:13>>*/ caml_call1(bos, s);
-     /*<<string.ml:89:20>>*/ return caml_call2(Stdlib_Bytes[22], f, _d_);
+    var _d_ =  /*<<string.ml:89:13>>*/ bos(s);
+     /*<<string.ml:89:20>>*/ return Stdlib_Bytes[22].call(null, f, _d_);
    }
    function for_all(f, s){
-    var _d_ =  /*<<string.ml:91:14>>*/ caml_call1(bos, s);
-     /*<<string.ml:91:21>>*/ return caml_call2(Stdlib_Bytes[21], f, _d_);
+    var _d_ =  /*<<string.ml:91:14>>*/ bos(s);
+     /*<<string.ml:91:21>>*/ return Stdlib_Bytes[21].call(null, f, _d_);
    }
    function is_space(param){
     var _d_ =  /*<<string.ml:97:15>>*/ param - 9 | 0;
@@ -6616,17 +6571,17 @@
         ( /*<<string.ml:103:35>>*/ caml_string_unsafe_get
           (s, caml_ml_string_length(s) - 1 | 0)))
       /*<<string.ml:105:7>>*/ return s;
-    var _d_ =  /*<<string.ml:104:21>>*/ caml_call1(bos, s);
-     /*<<string.ml:104:13>>*/ return  /*<<string.ml:104:29>>*/ caml_call1
-            (bts,  /*<<string.ml:104:13>>*/ caml_call1(Stdlib_Bytes[23], _d_)) /*<<string.ml:105:8>>*/ ;
+    var _d_ =  /*<<string.ml:104:21>>*/ bos(s);
+     /*<<string.ml:104:13>>*/ return  /*<<string.ml:104:29>>*/ bts
+            ( /*<<string.ml:104:13>>*/ Stdlib_Bytes[23].call(null, _d_)) /*<<string.ml:105:8>>*/ ;
    }
    function escaped(s){
     var
-     b =  /*<<string.ml:108:10>>*/ caml_call1(bos, s),
-     b$0 =  /*<<string.ml:111:11>>*/ caml_call1(Stdlib_Bytes[87], b);
+     b =  /*<<string.ml:108:10>>*/ bos(s),
+     b$0 =  /*<<string.ml:111:11>>*/ Stdlib_Bytes[87].call(null, b);
      /*<<string.ml:115:2>>*/ return b === b$0
             ? s
-            :  /*<<string.ml:115:25>>*/ caml_call1(bts, b$0) /*<<string.ml:115:31>>*/ ;
+            :  /*<<string.ml:115:25>>*/ bts(b$0) /*<<string.ml:115:31>>*/ ;
    }
    function index_rec(s, lim, i$1, c){
     var i =  /*<<string.ml:119:2>>*/ i$1;
@@ -6662,15 +6617,15 @@
     var l =  /*<<string.ml:135:2>>*/ caml_ml_string_length(s);
      /*<<string.ml:136:2>>*/ if(0 <= i && l >= i)
       /*<<string.ml:137:4>>*/ return index_rec(s, l, i, c) /*<<string.ml:137:21>>*/ ;
-     /*<<string.ml:136:25>>*/ return caml_call1
-            (Stdlib[1], cst_String_index_from_Bytes_in) /*<<string.ml:137:21>>*/ ;
+     /*<<string.ml:136:25>>*/ return Stdlib[1].call
+            (null, cst_String_index_from_Bytes_in) /*<<string.ml:137:21>>*/ ;
    }
    function index_from_opt(s, i, c){
     var l =  /*<<string.ml:141:2>>*/ caml_ml_string_length(s);
      /*<<string.ml:142:2>>*/ if(0 <= i && l >= i)
       /*<<string.ml:145:4>>*/ return index_rec_opt(s, l, i, c) /*<<string.ml:145:25>>*/ ;
-     /*<<string.ml:143:4>>*/ return caml_call1
-            (Stdlib[1], cst_String_index_from_opt_Byte) /*<<string.ml:145:25>>*/ ;
+     /*<<string.ml:143:4>>*/ return Stdlib[1].call
+            (null, cst_String_index_from_opt_Byte) /*<<string.ml:145:25>>*/ ;
    }
    function rindex_rec(s, i$1, c){
     var i =  /*<<string.ml:149:2>>*/ i$1;
@@ -6691,8 +6646,8 @@
    function rindex_from(s, i, c){
      /*<<string.ml:157:2>>*/ if(-1 <= i && caml_ml_string_length(s) > i)
       /*<<string.ml:160:4>>*/ return rindex_rec(s, i, c) /*<<string.ml:160:20>>*/ ;
-     /*<<string.ml:158:4>>*/ return caml_call1
-            (Stdlib[1], cst_String_rindex_from_Bytes_r) /*<<string.ml:160:20>>*/ ;
+     /*<<string.ml:158:4>>*/ return Stdlib[1].call
+            (null, cst_String_rindex_from_Bytes_r) /*<<string.ml:160:20>>*/ ;
    }
    function rindex_rec_opt(s, i$1, c){
     var i =  /*<<string.ml:164:2>>*/ i$1;
@@ -6711,8 +6666,8 @@
    function rindex_from_opt(s, i, c){
      /*<<string.ml:172:2>>*/ if(-1 <= i && caml_ml_string_length(s) > i)
       /*<<string.ml:175:4>>*/ return rindex_rec_opt(s, i, c) /*<<string.ml:175:24>>*/ ;
-     /*<<string.ml:173:4>>*/ return caml_call1
-            (Stdlib[1], cst_String_rindex_from_opt_Byt) /*<<string.ml:175:24>>*/ ;
+     /*<<string.ml:173:4>>*/ return Stdlib[1].call
+            (null, cst_String_rindex_from_opt_Byt) /*<<string.ml:175:24>>*/ ;
    }
    function contains_from(s, i, c){
     var l =  /*<<string.ml:179:2>>*/ caml_ml_string_length(s);
@@ -6727,8 +6682,8 @@
       if(exn === Stdlib[8])  /*<<string.ml:183:59>>*/ return 0;
        /*<<?>>*/ throw caml_maybe_attach_backtrace(exn, 0);
      }
-     /*<<string.ml:181:4>>*/ return caml_call1
-            (Stdlib[1], cst_String_contains_from_Bytes) /*<<string.ml:183:64>>*/ ;
+     /*<<string.ml:181:4>>*/ return Stdlib[1].call
+            (null, cst_String_contains_from_Bytes) /*<<string.ml:183:64>>*/ ;
    }
    function contains(s, c){
      /*<<string.ml:186:19>>*/ return contains_from(s, 0, c) /*<<string.ml:186:38>>*/ ;
@@ -6745,28 +6700,28 @@
       if(exn === Stdlib[8])  /*<<string.ml:193:58>>*/ return 0;
        /*<<?>>*/ throw caml_maybe_attach_backtrace(exn, 0);
      }
-     /*<<string.ml:191:4>>*/ return caml_call1
-            (Stdlib[1], cst_String_rcontains_from_Byte) /*<<string.ml:193:63>>*/ ;
+     /*<<string.ml:191:4>>*/ return Stdlib[1].call
+            (null, cst_String_rcontains_from_Byte) /*<<string.ml:193:63>>*/ ;
    }
    function uppercase_ascii(s){
-    var _d_ =  /*<<string.ml:196:20>>*/ caml_call1(bos, s);
-     /*<<string.ml:196:2>>*/ return  /*<<string.ml:196:27>>*/ caml_call1
-            (bts,  /*<<string.ml:196:2>>*/ caml_call1(Stdlib_Bytes[36], _d_)) /*<<string.ml:196:34>>*/ ;
+    var _d_ =  /*<<string.ml:196:20>>*/ bos(s);
+     /*<<string.ml:196:2>>*/ return  /*<<string.ml:196:27>>*/ bts
+            ( /*<<string.ml:196:2>>*/ Stdlib_Bytes[36].call(null, _d_)) /*<<string.ml:196:34>>*/ ;
    }
    function lowercase_ascii(s){
-    var _d_ =  /*<<string.ml:198:20>>*/ caml_call1(bos, s);
-     /*<<string.ml:198:2>>*/ return  /*<<string.ml:198:27>>*/ caml_call1
-            (bts,  /*<<string.ml:198:2>>*/ caml_call1(Stdlib_Bytes[37], _d_)) /*<<string.ml:198:34>>*/ ;
+    var _d_ =  /*<<string.ml:198:20>>*/ bos(s);
+     /*<<string.ml:198:2>>*/ return  /*<<string.ml:198:27>>*/ bts
+            ( /*<<string.ml:198:2>>*/ Stdlib_Bytes[37].call(null, _d_)) /*<<string.ml:198:34>>*/ ;
    }
    function capitalize_ascii(s){
-    var _d_ =  /*<<string.ml:200:21>>*/ caml_call1(bos, s);
-     /*<<string.ml:200:2>>*/ return  /*<<string.ml:200:28>>*/ caml_call1
-            (bts,  /*<<string.ml:200:2>>*/ caml_call1(Stdlib_Bytes[38], _d_)) /*<<string.ml:200:35>>*/ ;
+    var _d_ =  /*<<string.ml:200:21>>*/ bos(s);
+     /*<<string.ml:200:2>>*/ return  /*<<string.ml:200:28>>*/ bts
+            ( /*<<string.ml:200:2>>*/ Stdlib_Bytes[38].call(null, _d_)) /*<<string.ml:200:35>>*/ ;
    }
    function uncapitalize_ascii(s){
-    var _d_ =  /*<<string.ml:202:23>>*/ caml_call1(bos, s);
-     /*<<string.ml:202:2>>*/ return  /*<<string.ml:202:30>>*/ caml_call1
-            (bts,  /*<<string.ml:202:2>>*/ caml_call1(Stdlib_Bytes[39], _d_)) /*<<string.ml:202:37>>*/ ;
+    var _d_ =  /*<<string.ml:202:23>>*/ bos(s);
+     /*<<string.ml:202:2>>*/ return  /*<<string.ml:202:30>>*/ bts
+            ( /*<<string.ml:202:2>>*/ Stdlib_Bytes[39].call(null, _d_)) /*<<string.ml:202:37>>*/ ;
    }
    function starts_with(prefix, s){
     var
@@ -6830,80 +6785,80 @@
     /*<<string.ml:238:18>>*/ }
    var compare =  /*<<?>>*/ runtime.caml_string_compare;
    function to_seq(s){
-    var _a_ =  /*<<string.ml:247:15>>*/ caml_call1(bos, s);
-     /*<<string.ml:247:20>>*/ return caml_call1(Stdlib_Bytes[47], _a_) /*<<string.ml:247:32>>*/ ;
+    var _a_ =  /*<<string.ml:247:15>>*/ bos(s);
+     /*<<string.ml:247:20>>*/ return Stdlib_Bytes[47].call(null, _a_) /*<<string.ml:247:32>>*/ ;
    }
    function to_seqi(s){
-    var _a_ =  /*<<string.ml:249:16>>*/ caml_call1(bos, s);
-     /*<<string.ml:249:21>>*/ return caml_call1(Stdlib_Bytes[48], _a_) /*<<string.ml:249:34>>*/ ;
+    var _a_ =  /*<<string.ml:249:16>>*/ bos(s);
+     /*<<string.ml:249:21>>*/ return Stdlib_Bytes[48].call(null, _a_) /*<<string.ml:249:34>>*/ ;
    }
    function of_seq(g){
-     /*<<string.ml:251:15>>*/ return  /*<<string.ml:251:25>>*/ caml_call1
-            (bts,  /*<<string.ml:251:15>>*/ caml_call1(Stdlib_Bytes[49], g)) /*<<string.ml:251:32>>*/ ;
+     /*<<string.ml:251:15>>*/ return  /*<<string.ml:251:25>>*/ bts
+            ( /*<<string.ml:251:15>>*/ Stdlib_Bytes[49].call(null, g)) /*<<string.ml:251:32>>*/ ;
    }
    function get_utf_8_uchar(s, i){
-    var _a_ =  /*<<string.ml:255:44>>*/ caml_call1(bos, s);
-     /*<<string.ml:255:51>>*/ return caml_call2(Stdlib_Bytes[50], _a_, i) /*<<string.ml:255:53>>*/ ;
+    var _a_ =  /*<<string.ml:255:44>>*/ bos(s);
+     /*<<string.ml:255:51>>*/ return Stdlib_Bytes[50].call(null, _a_, i) /*<<string.ml:255:53>>*/ ;
    }
    function is_valid_utf_8(s){
-    var _a_ =  /*<<string.ml:256:40>>*/ caml_call1(bos, s);
-     /*<<string.ml:256:47>>*/ return caml_call1(Stdlib_Bytes[52], _a_);
+    var _a_ =  /*<<string.ml:256:40>>*/ bos(s);
+     /*<<string.ml:256:47>>*/ return Stdlib_Bytes[52].call(null, _a_);
    }
    function get_utf_16be_uchar(s, i){
-    var _a_ =  /*<<string.ml:258:50>>*/ caml_call1(bos, s);
-     /*<<string.ml:258:57>>*/ return caml_call2(Stdlib_Bytes[53], _a_, i) /*<<string.ml:258:59>>*/ ;
+    var _a_ =  /*<<string.ml:258:50>>*/ bos(s);
+     /*<<string.ml:258:57>>*/ return Stdlib_Bytes[53].call(null, _a_, i) /*<<string.ml:258:59>>*/ ;
    }
    function is_valid_utf_16be(s){
-    var _a_ =  /*<<string.ml:259:46>>*/ caml_call1(bos, s);
-     /*<<string.ml:259:53>>*/ return caml_call1(Stdlib_Bytes[55], _a_);
+    var _a_ =  /*<<string.ml:259:46>>*/ bos(s);
+     /*<<string.ml:259:53>>*/ return Stdlib_Bytes[55].call(null, _a_);
    }
    function get_utf_16le_uchar(s, i){
-    var _a_ =  /*<<string.ml:261:50>>*/ caml_call1(bos, s);
-     /*<<string.ml:261:57>>*/ return caml_call2(Stdlib_Bytes[56], _a_, i) /*<<string.ml:261:59>>*/ ;
+    var _a_ =  /*<<string.ml:261:50>>*/ bos(s);
+     /*<<string.ml:261:57>>*/ return Stdlib_Bytes[56].call(null, _a_, i) /*<<string.ml:261:59>>*/ ;
    }
    function is_valid_utf_16le(s){
-    var _a_ =  /*<<string.ml:262:46>>*/ caml_call1(bos, s);
-     /*<<string.ml:262:53>>*/ return caml_call1(Stdlib_Bytes[58], _a_);
+    var _a_ =  /*<<string.ml:262:46>>*/ bos(s);
+     /*<<string.ml:262:53>>*/ return Stdlib_Bytes[58].call(null, _a_);
    }
    function get_int8(s, i){
-    var _a_ =  /*<<string.ml:271:30>>*/ caml_call1(bos, s);
-     /*<<string.ml:271:37>>*/ return caml_call2(Stdlib_Bytes[60], _a_, i) /*<<string.ml:271:39>>*/ ;
+    var _a_ =  /*<<string.ml:271:30>>*/ bos(s);
+     /*<<string.ml:271:37>>*/ return Stdlib_Bytes[60].call(null, _a_, i) /*<<string.ml:271:39>>*/ ;
    }
    function get_uint16_le(s, i){
-    var _a_ =  /*<<string.ml:272:40>>*/ caml_call1(bos, s);
-     /*<<string.ml:272:47>>*/ return caml_call2(Stdlib_Bytes[63], _a_, i) /*<<string.ml:272:49>>*/ ;
+    var _a_ =  /*<<string.ml:272:40>>*/ bos(s);
+     /*<<string.ml:272:47>>*/ return Stdlib_Bytes[63].call(null, _a_, i) /*<<string.ml:272:49>>*/ ;
    }
    function get_uint16_be(s, i){
-    var _a_ =  /*<<string.ml:273:40>>*/ caml_call1(bos, s);
-     /*<<string.ml:273:47>>*/ return caml_call2(Stdlib_Bytes[62], _a_, i) /*<<string.ml:273:49>>*/ ;
+    var _a_ =  /*<<string.ml:273:40>>*/ bos(s);
+     /*<<string.ml:273:47>>*/ return Stdlib_Bytes[62].call(null, _a_, i) /*<<string.ml:273:49>>*/ ;
    }
    function get_int16_ne(s, i){
-    var _a_ =  /*<<string.ml:274:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:274:45>>*/ return caml_call2(Stdlib_Bytes[64], _a_, i) /*<<string.ml:274:47>>*/ ;
+    var _a_ =  /*<<string.ml:274:38>>*/ bos(s);
+     /*<<string.ml:274:45>>*/ return Stdlib_Bytes[64].call(null, _a_, i) /*<<string.ml:274:47>>*/ ;
    }
    function get_int16_le(s, i){
-    var _a_ =  /*<<string.ml:275:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:275:45>>*/ return caml_call2(Stdlib_Bytes[66], _a_, i) /*<<string.ml:275:47>>*/ ;
+    var _a_ =  /*<<string.ml:275:38>>*/ bos(s);
+     /*<<string.ml:275:45>>*/ return Stdlib_Bytes[66].call(null, _a_, i) /*<<string.ml:275:47>>*/ ;
    }
    function get_int16_be(s, i){
-    var _a_ =  /*<<string.ml:276:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:276:45>>*/ return caml_call2(Stdlib_Bytes[65], _a_, i) /*<<string.ml:276:47>>*/ ;
+    var _a_ =  /*<<string.ml:276:38>>*/ bos(s);
+     /*<<string.ml:276:45>>*/ return Stdlib_Bytes[65].call(null, _a_, i) /*<<string.ml:276:47>>*/ ;
    }
    function get_int32_le(s, i){
-    var _a_ =  /*<<string.ml:277:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:277:45>>*/ return caml_call2(Stdlib_Bytes[69], _a_, i) /*<<string.ml:277:47>>*/ ;
+    var _a_ =  /*<<string.ml:277:38>>*/ bos(s);
+     /*<<string.ml:277:45>>*/ return Stdlib_Bytes[69].call(null, _a_, i) /*<<string.ml:277:47>>*/ ;
    }
    function get_int32_be(s, i){
-    var _a_ =  /*<<string.ml:278:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:278:45>>*/ return caml_call2(Stdlib_Bytes[68], _a_, i) /*<<string.ml:278:47>>*/ ;
+    var _a_ =  /*<<string.ml:278:38>>*/ bos(s);
+     /*<<string.ml:278:45>>*/ return Stdlib_Bytes[68].call(null, _a_, i) /*<<string.ml:278:47>>*/ ;
    }
    function get_int64_le(s, i){
-    var _a_ =  /*<<string.ml:279:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:279:45>>*/ return caml_call2(Stdlib_Bytes[72], _a_, i) /*<<string.ml:279:47>>*/ ;
+    var _a_ =  /*<<string.ml:279:38>>*/ bos(s);
+     /*<<string.ml:279:45>>*/ return Stdlib_Bytes[72].call(null, _a_, i) /*<<string.ml:279:47>>*/ ;
    }
    function get_int64_be(s, i){
-    var _a_ =  /*<<string.ml:280:38>>*/ caml_call1(bos, s);
-     /*<<string.ml:280:45>>*/ return caml_call2(Stdlib_Bytes[71], _a_, i) /*<<string.ml:280:47>>*/ ;
+    var _a_ =  /*<<string.ml:280:38>>*/ bos(s);
+     /*<<string.ml:280:45>>*/ return Stdlib_Bytes[71].call(null, _a_, i) /*<<string.ml:280:47>>*/ ;
    }
    var
     Stdlib_String =
@@ -7008,13 +6963,7 @@
     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
+    caml_ml_bytes_length = runtime.caml_ml_bytes_length,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Bytes = global_data.Stdlib__Bytes,
     Stdlib = global_data.Stdlib,
@@ -7025,8 +6974,8 @@
      (0 <= ofs && 0 <= len && (caml_ml_bytes_length(buff) - len | 0) >= ofs)
       /*<<marshal.ml:36:7>>*/ return runtime.caml_output_value_to_buffer
              (buff, ofs, len, v, flags) /*<<marshal.ml:36:44>>*/ ;
-     /*<<marshal.ml:35:7>>*/ return caml_call1
-            (Stdlib[1], cst_Marshal_to_buffer_substrin) /*<<marshal.ml:36:44>>*/ ;
+     /*<<marshal.ml:35:7>>*/ return Stdlib[1].call
+            (null, cst_Marshal_to_buffer_substrin) /*<<marshal.ml:36:44>>*/ ;
    }
    var
     cst_Marshal_data_size =  /*<<?>>*/ "Marshal.data_size",
@@ -7036,8 +6985,8 @@
      /*<<marshal.ml:50:2>>*/ if
      (0 <= ofs && (caml_ml_bytes_length(buff) - 16 | 0) >= ofs)
       /*<<marshal.ml:52:7>>*/ return caml_marshal_data_size(buff, ofs) /*<<marshal.ml:52:32>>*/ ;
-     /*<<marshal.ml:51:7>>*/ return caml_call1
-            (Stdlib[1], cst_Marshal_data_size) /*<<marshal.ml:52:32>>*/ ;
+     /*<<marshal.ml:51:7>>*/ return Stdlib[1].call
+            (null, cst_Marshal_data_size) /*<<marshal.ml:52:32>>*/ ;
    }
    function total_size(buff, ofs){
      /*<<marshal.ml:53:40>>*/ return 16 + data_size(buff, ofs) | 0 /*<<marshal.ml:53:58>>*/ ;
@@ -7050,18 +6999,18 @@
              - (16 + len | 0)
              | 0)
              < ofs
-             ?  /*<<marshal.ml:61:9>>*/ caml_call1
-               (Stdlib[1], cst_Marshal_from_bytes$0)
+             ?  /*<<marshal.ml:61:9>>*/ Stdlib
+                [1].call
+               (null, cst_Marshal_from_bytes$0)
              :  /*<<marshal.ml:62:9>>*/ runtime.caml_input_value_from_bytes
                (buff, ofs) /*<<marshal.ml:63:5>>*/ ;
     }
-     /*<<marshal.ml:57:7>>*/ return caml_call1
-            (Stdlib[1], cst_Marshal_from_bytes) /*<<marshal.ml:63:5>>*/ ;
+     /*<<marshal.ml:57:7>>*/ return Stdlib[1].call
+            (null, cst_Marshal_from_bytes) /*<<marshal.ml:63:5>>*/ ;
    }
    function from_string(buff, ofs){
      /*<<marshal.ml:68:13>>*/ return  /*<<marshal.ml:68:42>>*/ from_bytes
-            ( /*<<marshal.ml:68:13>>*/ caml_call1(Stdlib_Bytes[45], buff),
-             ofs) /*<<marshal.ml:68:46>>*/ ;
+            ( /*<<marshal.ml:68:13>>*/ Stdlib_Bytes[45].call(null, buff), ofs) /*<<marshal.ml:68:46>>*/ ;
    }
    var
     Stdlib_Marshal =
@@ -7102,11 +7051,6 @@
             ? 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 = "",
@@ -7131,7 +7075,7 @@
    function init(l, f){
      /*<<array.ml:48:2>>*/ if(0 === l)  /*<<array.ml:48:16>>*/ return [0];
      /*<<array.ml:49:2>>*/ if(0 > l)
-      /*<<array.ml:49:16>>*/ return caml_call1(Stdlib[1], cst_Array_init) /*<<array.ml:58:6>>*/ ;
+      /*<<array.ml:49:16>>*/ return Stdlib[1].call(null, cst_Array_init) /*<<array.ml:58:6>>*/ ;
     var
      res =
         /*<<array.ml:54:22>>*/  /*<<array.ml:54:13>>*/ caml_array_make
@@ -7151,7 +7095,7 @@
     /*<<array.ml:58:6>>*/ }
    function make_matrix(sx, sy, init){
      /*<<array.ml:62:2>>*/ if(sy < 0)
-      /*<<array.ml:62:17>>*/ caml_call1(Stdlib[1], cst_Array_make_matrix);
+      /*<<array.ml:62:17>>*/ Stdlib[1].call(null, cst_Array_make_matrix);
     var res =  /*<<array.ml:63:12>>*/ caml_array_make(sx, [0]);
      /*<<array.ml:64:2>>*/ if(0 < sy){
      var _ak_ =  /*<<array.ml:64:17>>*/ sx - 1 | 0, _al_ = 0;
@@ -7169,7 +7113,7 @@
     /*<<array.ml:69:5>>*/ }
    function init_matrix(sx, sy, f){
      /*<<array.ml:73:2>>*/ if(sy < 0)
-      /*<<array.ml:73:17>>*/ caml_call1(Stdlib[1], cst_Array_init_matrix);
+      /*<<array.ml:73:17>>*/ Stdlib[1].call(null, cst_Array_init_matrix);
     var res =  /*<<array.ml:74:12>>*/ caml_array_make(sx, [0]);
      /*<<array.ml:76:2>>*/ if(0 < sy){
      var _af_ =  /*<<array.ml:76:17>>*/ sx - 1 | 0, _ah_ = 0;
@@ -7219,13 +7163,13 @@
      /*<<array.ml:97:2>>*/ if
      (0 <= ofs && 0 <= len && (a.length - 1 - len | 0) >= ofs)
       /*<<array.ml:99:7>>*/ return caml_array_sub(a, ofs, len) /*<<array.ml:99:27>>*/ ;
-     /*<<array.ml:98:7>>*/ return caml_call1(Stdlib[1], cst_Array_sub) /*<<array.ml:99:27>>*/ ;
+     /*<<array.ml:98:7>>*/ return Stdlib[1].call(null, cst_Array_sub) /*<<array.ml:99:27>>*/ ;
    }
    function fill(a, ofs, len, v){
      /*<<array.ml:102:2>>*/ if
      (0 <= ofs && 0 <= len && (a.length - 1 - len | 0) >= ofs)
       /*<<array.ml:104:7>>*/ return runtime.caml_array_fill(a, ofs, len, v) /*<<array.ml:104:30>>*/ ;
-     /*<<array.ml:103:7>>*/ return caml_call1(Stdlib[1], cst_Array_fill) /*<<array.ml:104:30>>*/ ;
+     /*<<array.ml:103:7>>*/ return Stdlib[1].call(null, cst_Array_fill) /*<<array.ml:104:30>>*/ ;
    }
    function blit(a1, ofs1, a2, ofs2, len){
      /*<<array.ml:107:2>>*/ if
@@ -7237,7 +7181,7 @@
         && 0 <= ofs2 && (a2.length - 1 - len | 0) >= ofs2)
       /*<<array.ml:110:7>>*/ return runtime.caml_array_blit
              (a1, ofs1, a2, ofs2, len) /*<<array.ml:110:38>>*/ ;
-     /*<<array.ml:109:7>>*/ return caml_call1(Stdlib[1], cst_Array_blit) /*<<array.ml:110:38>>*/ ;
+     /*<<array.ml:109:7>>*/ return Stdlib[1].call(null, cst_Array_blit) /*<<array.ml:110:38>>*/ ;
    }
    function iter(f, a){
     var _ad_ =  /*<<array.ml:113:2>>*/ a.length - 2 | 0, _ae_ = 0;
@@ -7254,8 +7198,8 @@
     /*<<array.ml:113:53>>*/ }
    function iter2(f, a, b){
      /*<<array.ml:116:2>>*/ if(a.length - 1 !== b.length - 1)
-      /*<<array.ml:117:4>>*/ return caml_call1
-             (Stdlib[1], cst_Array_iter2_arrays_must_ha) /*<<array.ml:119:73>>*/ ;
+      /*<<array.ml:117:4>>*/ return Stdlib[1].call
+             (null, cst_Array_iter2_arrays_must_ha) /*<<array.ml:119:73>>*/ ;
     var _ab_ =  /*<<array.ml:119:4>>*/ a.length - 2 | 0, _ac_ = 0;
     if(_ab_ >= 0){
      var i = _ac_;
@@ -7319,8 +7263,8 @@
      la =  /*<<array.ml:142:2>>*/ a.length - 1,
      lb =  /*<<array.ml:143:2>>*/ b.length - 1;
      /*<<array.ml:144:2>>*/ if(la !== lb)
-      /*<<array.ml:145:4>>*/ return caml_call1
-             (Stdlib[1], cst_Array_map2_arrays_must_hav) /*<<array.ml:154:5>>*/ ;
+      /*<<array.ml:145:4>>*/ return Stdlib[1].call
+             (null, cst_Array_map2_arrays_must_hav) /*<<array.ml:154:5>>*/ ;
      /*<<array.ml:146:7>>*/ if(0 === la)  /*<<array.ml:147:19>>*/ return [0];
     var
      r =
@@ -7498,7 +7442,7 @@
    function for_all2(p, l1, l2){
     var n1 =  /*<<array.ml:233:2>>*/ l1.length - 1, n2 = l2.length - 1;
      /*<<array.ml:235:2>>*/ if(n1 !== n2)
-      /*<<array.ml:235:19>>*/ return caml_call1(Stdlib[1], cst_Array_for_all2) /*<<array.ml:240:8>>*/ ;
+      /*<<array.ml:235:19>>*/ return Stdlib[1].call(null, cst_Array_for_all2) /*<<array.ml:240:8>>*/ ;
     var i =  /*<<array.ml:240:2>>*/ 0;
     for(;;){
       /*<<array.ml:237:4>>*/ if(i === n1)  /*<<array.ml:237:19>>*/ return 1;
@@ -7511,7 +7455,7 @@
    function exists2(p, l1, l2){
     var n1 =  /*<<array.ml:243:2>>*/ l1.length - 1, n2 = l2.length - 1;
      /*<<array.ml:245:2>>*/ if(n1 !== n2)
-      /*<<array.ml:245:19>>*/ return caml_call1(Stdlib[1], cst_Array_exists2) /*<<array.ml:250:8>>*/ ;
+      /*<<array.ml:245:19>>*/ return Stdlib[1].call(null, cst_Array_exists2) /*<<array.ml:250:8>>*/ ;
     var i =  /*<<array.ml:250:2>>*/ 0;
     for(;;){
       /*<<array.ml:247:4>>*/ if(i === n1)  /*<<array.ml:247:19>>*/ return 0;
@@ -7627,7 +7571,7 @@
      na =  /*<<array.ml:325:2>>*/ a.length - 1,
      nb =  /*<<array.ml:326:2>>*/ b.length - 1;
      /*<<array.ml:327:2>>*/ if(na !== nb)
-      /*<<array.ml:327:19>>*/ caml_call1(Stdlib[1], cst_Array_combine);
+      /*<<array.ml:327:19>>*/ Stdlib[1].call(null, cst_Array_combine);
      /*<<array.ml:328:2>>*/ if(0 === na)  /*<<array.ml:328:17>>*/ return [0];
     var
      x =  /*<<array.ml:330:12>>*/ caml_array_make(na, [0, a[1], b[1]]),
@@ -7923,17 +7867,14 @@
         _h_ =
            /*<<array.ml:447:36>>*/ [0,
            cst_out_of_expected_range_0,
-           [0, caml_call1(int$, i), _b_]],
-        _i_ =
-           /*<<array.ml:446:19>>*/ [0,
-           cst_returned,
-           [0, caml_call1(int$, j), _h_]],
+           [0, int$(i), _b_]],
+        _i_ =  /*<<array.ml:446:19>>*/ [0, cst_returned, [0, int$(j), _h_]],
         _j_ =
            /*<<array.ml:445:29>>*/ [0,
            cst_Array_shuffle_rand,
-           [0, caml_call1(int$, i + 1 | 0), _i_]],
-        _k_ =  /*<<array.ml:444:2>>*/ caml_call2(Stdlib_String[7], cst, _j_);
-        /*<<array.ml:448:3>>*/ caml_call1(Stdlib[1], _k_);
+           [0, int$(i + 1 | 0), _i_]],
+        _k_ =  /*<<array.ml:444:2>>*/ Stdlib_String[7].call(null, cst, _j_);
+        /*<<array.ml:448:3>>*/ Stdlib[1].call(null, _k_);
       }
       var v =  /*<<array.ml:455:12>>*/ a[i + 1];
        /*<<array.ml:456:4>>*/ a[i + 1] = a[j + 1];
@@ -7978,8 +7919,8 @@
    function of_seq(i$2){
     var
      l =
-        /*<<array.ml:494:10>>*/ caml_call3
-        (Stdlib_Seq[5],
+        /*<<array.ml:494:10>>*/ Stdlib_Seq[5].call
+        (null,
          function(acc, x){
            /*<<array.ml:494:38>>*/ return [0, x, acc];
           /*<<array.ml:494:44>>*/ },
@@ -8085,11 +8026,6 @@
             ? 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,
@@ -8226,7 +8162,7 @@
        _ap_ = (ofs + len | 0) < 0 ? 1 : 0,
        _am_ = _ap_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0);
     }
-    return _am_ ?  /*<<float.ml:198:6>>*/ caml_call1(Stdlib[1], msg) : _am_ /*<<float.ml:198:21>>*/ ;
+    return _am_ ?  /*<<float.ml:198:6>>*/ Stdlib[1].call(null, msg) : _am_ /*<<float.ml:198:21>>*/ ;
    }
    var
     empty =  /*<<float.ml:200:14>>*/ caml_floatarray_create(0),
@@ -8245,8 +8181,8 @@
       "Float.Array.map2: arrays must have the same length";
    function init(l, f){
      /*<<float.ml:203:4>>*/ if(0 > l)
-      /*<<float.ml:203:18>>*/ return caml_call1
-             (Stdlib[1], cst_Float_Array_init) /*<<float.ml:209:9>>*/ ;
+      /*<<float.ml:203:18>>*/ return Stdlib[1].call
+             (null, cst_Float_Array_init) /*<<float.ml:209:9>>*/ ;
     var
      res =  /*<<float.ml:205:16>>*/ caml_floatarray_create(l),
      _ak_ =  /*<<float.ml:206:6>>*/ l - 1 | 0,
@@ -8264,8 +8200,8 @@
     /*<<float.ml:209:9>>*/ }
    function make_matrix(sx, sy, v){
      /*<<float.ml:213:4>>*/ if(sy < 0)
-      /*<<float.ml:213:19>>*/ caml_call1
-      (Stdlib[1], cst_Float_Array_make_matrix);
+      /*<<float.ml:213:19>>*/ Stdlib[1].call
+      (null, cst_Float_Array_make_matrix);
     var
      res =
         /*<<float.ml:214:28>>*/  /*<<float.ml:214:14>>*/ caml_array_make
@@ -8286,8 +8222,8 @@
     /*<<float.ml:220:7>>*/ }
    function init_matrix(sx, sy, f){
      /*<<float.ml:224:4>>*/ if(sy < 0)
-      /*<<float.ml:224:19>>*/ caml_call1
-      (Stdlib[1], cst_Float_Array_init_matrix);
+      /*<<float.ml:224:19>>*/ Stdlib[1].call
+      (null, cst_Float_Array_init_matrix);
     var
      res =
         /*<<float.ml:225:28>>*/  /*<<float.ml:225:14>>*/ caml_array_make
@@ -8333,7 +8269,7 @@
      }
      else{
        /*<<float.ml:239:26>>*/ acc =
-       caml_call1(Stdlib[1], cst_Float_Array_concat);
+       Stdlib[1].call(null, cst_Float_Array_concat);
       param = tl;
      }
     }
@@ -8389,8 +8325,8 @@
             (src, sofs, dst, dofs, len) /*<<float.ml:281:37>>*/ ;
    }
    function to_list(a){
-     /*<<float.ml:284:39>>*/ return caml_call2
-            (Stdlib_List[11],
+     /*<<float.ml:284:39>>*/ return Stdlib_List[11].call
+            (null,
              a.length - 1,
              function(_ad_){ /*<<float.ml:284:25>>*/ return a[_ad_ + 1];}) /*<<float.ml:284:39>>*/ ;
    }
@@ -8398,7 +8334,7 @@
     var
      result =
         /*<<float.ml:287:24>>*/  /*<<float.ml:287:17>>*/ caml_floatarray_create
-        ( /*<<float.ml:287:24>>*/ caml_call1(Stdlib_List[1], l)),
+        ( /*<<float.ml:287:24>>*/ Stdlib_List[1].call(null, l)),
      i =  /*<<float.ml:293:4>>*/ 0,
      l$0 = l;
     for(;;){
@@ -8425,8 +8361,8 @@
     /*<<float.ml:297:56>>*/ }
    function iter2(f, a, b){
      /*<<float.ml:301:4>>*/ if(a.length - 1 !== b.length - 1)
-      /*<<float.ml:302:6>>*/ return caml_call1
-             (Stdlib[1], cst_Float_Array_iter2_arrays_m) /*<<float.ml:304:75>>*/ ;
+      /*<<float.ml:302:6>>*/ return Stdlib[1].call
+             (null, cst_Float_Array_iter2_arrays_m) /*<<float.ml:304:75>>*/ ;
     var _$_ =  /*<<float.ml:304:6>>*/ a.length - 2 | 0, _aa_ = 0;
     if(_$_ >= 0){
      var i = _aa_;
@@ -8474,8 +8410,8 @@
      la =  /*<<float.ml:321:4>>*/ a.length - 1,
      lb =  /*<<float.ml:322:4>>*/ b.length - 1;
      /*<<float.ml:323:4>>*/ if(la !== lb)
-      /*<<float.ml:324:6>>*/ return caml_call1
-             (Stdlib[1], cst_Float_Array_map2_arrays_mu) /*<<float.ml:331:7>>*/ ;
+      /*<<float.ml:324:6>>*/ return Stdlib[1].call
+             (null, cst_Float_Array_map2_arrays_mu) /*<<float.ml:331:7>>*/ ;
     var
      r =  /*<<float.ml:326:14>>*/ caml_floatarray_create(la),
      _V_ =  /*<<float.ml:327:6>>*/ la - 1 | 0,
@@ -8972,14 +8908,14 @@
    function of_seq(i$2){
     var
      l =
-        /*<<float.ml:598:12>>*/ caml_call3
-        (Stdlib_Seq[5],
+        /*<<float.ml:598:12>>*/ Stdlib_Seq[5].call
+        (null,
          function(acc, x){
            /*<<float.ml:598:40>>*/ return [0, x, acc];
           /*<<float.ml:598:46>>*/ },
          0,
          i$2),
-     len =  /*<<float.ml:588:14>>*/ caml_call1(Stdlib_List[1], l),
+     len =  /*<<float.ml:588:14>>*/ Stdlib_List[1].call(null, l),
      a =  /*<<float.ml:589:12>>*/ caml_floatarray_create(len),
      i$1 =  /*<<float.ml:594:4>>*/ len - 1 | 0,
      i = i$1,
@@ -9585,31 +9521,11 @@
     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],
@@ -9665,8 +9581,8 @@
                /*<<lexing.ml:96:69>>*/ if
                (((lexbuf[3] - lexbuf[5] | 0) + n | 0)
                 <= caml_ml_bytes_length(lexbuf[2]))
-                /*<<lexing.ml:100:9>>*/ caml_call5
-                (Stdlib_Bytes[11],
+                /*<<lexing.ml:100:9>>*/ Stdlib_Bytes[11].call
+                (null,
                  lexbuf[2],
                  lexbuf[5],
                  lexbuf[2],
@@ -9675,20 +9591,21 @@
               else{
                var
                 newlen =
-                   /*<<lexing.ml:106:13>>*/  /*<<lexing.ml:111:8>>*/ caml_call2
-                   (Stdlib_Int[10],
+                   /*<<lexing.ml:106:13>>*/  /*<<lexing.ml:111:8>>*/ Stdlib_Int
+                    [10].call
+                   (null,
                     2
                     *  /*<<lexing.ml:106:13>>*/ caml_ml_bytes_length(lexbuf[2])
                     | 0,
                     Stdlib_Sys[12]);
                 /*<<lexing.ml:112:6>>*/ if
                 (newlen < ((lexbuf[3] - lexbuf[5] | 0) + n | 0))
-                 /*<<lexing.ml:113:11>>*/ caml_call1
-                 (Stdlib[2], cst_Lexing_lex_refill_cannot_g);
+                 /*<<lexing.ml:113:11>>*/ Stdlib[2].call
+                 (null, cst_Lexing_lex_refill_cannot_g);
                var
                 newbuf =  /*<<lexing.ml:114:19>>*/ caml_create_bytes(newlen);
-                /*<<lexing.ml:116:6>>*/ caml_call5
-                (Stdlib_Bytes[11],
+                /*<<lexing.ml:116:6>>*/ Stdlib_Bytes[11].call
+                (null,
                  lexbuf[2],
                  lexbuf[5],
                  newbuf,
@@ -9719,8 +9636,8 @@
                }
               }
              }
-              /*<<lexing.ml:137:2>>*/ caml_call5
-              (Stdlib_Bytes[11], aux_buffer, 0, lexbuf[2], lexbuf[3], n);
+              /*<<lexing.ml:137:2>>*/ Stdlib_Bytes[11].call
+              (null, aux_buffer, 0, lexbuf[2], lexbuf[3], n);
               /*<<lexing.ml:137:67>>*/ lexbuf[3] = lexbuf[3] + n | 0;
              return 0;
             },
@@ -9740,14 +9657,14 @@
      /*<<lexing.ml:163:2>>*/ return from_function
             (with_positions,
              function(buf, n){
-               /*<<lexing.ml:163:46>>*/ return caml_call4
-                      (Stdlib[84], ic, buf, 0, n) /*<<lexing.ml:163:62>>*/ ;
+               /*<<lexing.ml:163:46>>*/ return Stdlib[84].call
+                      (null, ic, buf, 0, n) /*<<lexing.ml:163:62>>*/ ;
              }) /*<<lexing.ml:163:63>>*/ ;
    }
    function from_string(opt, s){
     var
      with_positions =  /*<<lexing.ml:165:16>>*/ opt ? opt[1] : 1,
-     lex_buffer =  /*<<lexing.ml:169:19>>*/ caml_call1(Stdlib_Bytes[5], s),
+     lex_buffer =  /*<<lexing.ml:169:19>>*/ Stdlib_Bytes[5].call(null, s),
      _b_ =  /*<<lexing.ml:170:2>>*/ with_positions ? zero_pos : dummy_pos,
      _c_ = with_positions ? zero_pos : dummy_pos;
     return [0,
@@ -9783,19 +9700,19 @@
     /*<<lexing.ml:191:58>>*/ }
    function lexeme(lexbuf){
     var len =  /*<<lexing.ml:194:2>>*/ lexbuf[6] - lexbuf[5] | 0;
-     /*<<lexing.ml:195:2>>*/ return caml_call3
-            (Stdlib_Bytes[8], lexbuf[2], lexbuf[5], len) /*<<lexing.ml:195:61>>*/ ;
+     /*<<lexing.ml:195:2>>*/ return Stdlib_Bytes[8].call
+            (null, lexbuf[2], lexbuf[5], len) /*<<lexing.ml:195:61>>*/ ;
    }
    function sub_lexeme(lexbuf, i1, i2){
     var len =  /*<<lexing.ml:198:2>>*/ i2 - i1 | 0;
-     /*<<lexing.ml:199:2>>*/ return caml_call3
-            (Stdlib_Bytes[8], lexbuf[2], i1, len) /*<<lexing.ml:199:43>>*/ ;
+     /*<<lexing.ml:199:2>>*/ return Stdlib_Bytes[8].call
+            (null, lexbuf[2], i1, len) /*<<lexing.ml:199:43>>*/ ;
    }
    function sub_lexeme_opt(lexbuf, i1, i2){
      /*<<lexing.ml:202:2>>*/ if(0 > i1)  /*<<lexing.ml:205:11>>*/ return 0;
     var len =  /*<<lexing.ml:202:18>>*/ i2 - i1 | 0;
      /*<<lexing.ml:204:9>>*/ return [0,
-            caml_call3(Stdlib_Bytes[8], lexbuf[2], i1, len)] /*<<lexing.ml:204:52>>*/ ;
+            Stdlib_Bytes[8].call(null, lexbuf[2], i1, len)] /*<<lexing.ml:204:52>>*/ ;
     /*<<lexing.ml:207:5>>*/ }
    function sub_lexeme_char(lexbuf, i){
      /*<<lexing.ml:209:31>>*/ return caml_bytes_get(lexbuf[2], i) /*<<lexing.ml:209:60>>*/ ;
@@ -9888,16 +9805,6 @@
             ? 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]);
-   }
    var
     global_data = runtime.caml_get_global_data(),
     Stdlib_Obj = global_data.Stdlib__Obj,
@@ -9934,23 +9841,22 @@
         /*<<parsing.ml:112:18>>*/ caml_array_make(newsize, Stdlib_Lexing[1]),
      new_end =
         /*<<parsing.ml:113:16>>*/ caml_array_make(newsize, Stdlib_Lexing[1]);
-     /*<<parsing.ml:114:4>>*/ caml_call5
-     (Stdlib_Array[9], env[1], 0, new_s, 0, oldsize);
+     /*<<parsing.ml:114:4>>*/ Stdlib_Array[9].call
+     (null, env[1], 0, new_s, 0, oldsize);
      /*<<parsing.ml:114:44>>*/ env[1] = new_s;
-     /*<<parsing.ml:116:4>>*/ caml_call5
-     (Stdlib_Array[9], env[2], 0, new_v, 0, oldsize);
+     /*<<parsing.ml:116:4>>*/ Stdlib_Array[9].call
+     (null, env[2], 0, new_v, 0, oldsize);
      /*<<parsing.ml:116:44>>*/ env[2] = new_v;
-     /*<<parsing.ml:118:4>>*/ caml_call5
-     (Stdlib_Array[9], env[3], 0, new_start, 0, oldsize);
+     /*<<parsing.ml:118:4>>*/ Stdlib_Array[9].call
+     (null, env[3], 0, new_start, 0, oldsize);
      /*<<parsing.ml:118:57>>*/ env[3] = new_start;
-     /*<<parsing.ml:120:4>>*/ caml_call5
-     (Stdlib_Array[9], env[4], 0, new_end, 0, oldsize);
+     /*<<parsing.ml:120:4>>*/ Stdlib_Array[9].call
+     (null, env[4], 0, new_end, 0, oldsize);
      /*<<parsing.ml:120:53>>*/ env[4] = new_end;
      /*<<parsing.ml:122:4>>*/ env[5] = newsize;
     /*<<parsing.ml:122:28>>*/ }
    function clear_parser(param){
-     /*<<parsing.ml:125:2>>*/ caml_call4
-     (Stdlib_Array[8], env[2], 0, env[5], 0);
+     /*<<parsing.ml:125:2>>*/ Stdlib_Array[8].call(null, env[2], 0, env[5], 0);
      /*<<parsing.ml:125:54>>*/ env[8] = 0;
     return 0;
     /*<<parsing.ml:126:25>>*/ }
@@ -10037,7 +9943,7 @@
      if(tag === YYexit){var v = exn$0[2];  /*<<parsing.ml:177:8>>*/ return v;}
       /*<<parsing.ml:179:8>>*/ current_lookahead_fun[1] =
       function(tok){
-        /*<<parsing.ml:181:15>>*/ if(! caml_call1(Stdlib_Obj[1], tok))
+        /*<<parsing.ml:181:15>>*/ if(! Stdlib_Obj[1].call(null, tok))
          /*<<parsing.ml:183:17>>*/ return caml_check_bound(tables[2], tok)
                  [tok + 1]
                 === curr_char
@@ -10149,11 +10055,6 @@
             ? 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,
@@ -10199,7 +10100,7 @@
           var hr =  /*<<set.ml:102:37>>*/ 0;
           /*<<set.ml:103:6>>*/ if((hr + 2 | 0) < hl){
            /*<<set.ml:103:26>>*/ if(! l)
-            /*<<set.ml:105:19>>*/ return caml_call1(Stdlib[1], cst_Set_bal$0) /*<<set.ml:128:62>>*/ ;
+            /*<<set.ml:105:19>>*/ return Stdlib[1].call(null, cst_Set_bal$0) /*<<set.ml:128:62>>*/ ;
           var
            lr =  /*<<set.ml:103:26>>*/ l[3],
            lv = l[2],
@@ -10209,7 +10110,7 @@
             /*<<set.ml:108:27>>*/ return  /*<<set.ml:108:42>>*/ create
                    (ll, lv,  /*<<set.ml:108:27>>*/ create(lr, v, r)) /*<<set.ml:128:62>>*/ ;
            /*<<set.ml:109:17>>*/ if(! lr)
-            /*<<set.ml:111:25>>*/ return caml_call1(Stdlib[1], cst_Set_bal) /*<<set.ml:128:62>>*/ ;
+            /*<<set.ml:111:25>>*/ return Stdlib[1].call(null, cst_Set_bal) /*<<set.ml:128:62>>*/ ;
           var
            lrr =  /*<<set.ml:109:17>>*/ lr[3],
            lrv = lr[2],
@@ -10223,7 +10124,7 @@
           return [0, l, v, r, _y_];
          }
           /*<<set.ml:115:35>>*/ if(! r)
-           /*<<set.ml:117:19>>*/ return caml_call1(Stdlib[1], cst_Set_bal$2) /*<<set.ml:128:62>>*/ ;
+           /*<<set.ml:117:19>>*/ return Stdlib[1].call(null, cst_Set_bal$2) /*<<set.ml:128:62>>*/ ;
          var
           rr =  /*<<set.ml:115:35>>*/ r[3],
           rv = r[2],
@@ -10233,7 +10134,7 @@
            /*<<set.ml:120:21>>*/ return  /*<<set.ml:120:36>>*/ create
                   ( /*<<set.ml:120:21>>*/ create(l, v, rl), rv, rr) /*<<set.ml:128:62>>*/ ;
           /*<<set.ml:121:17>>*/ if(! rl)
-           /*<<set.ml:123:25>>*/ return caml_call1(Stdlib[1], cst_Set_bal$1) /*<<set.ml:128:62>>*/ ;
+           /*<<set.ml:123:25>>*/ return Stdlib[1].call(null, cst_Set_bal$1) /*<<set.ml:128:62>>*/ ;
          var
           rlr =  /*<<set.ml:121:17>>*/ rl[3],
           rlv = rl[2],
@@ -10352,8 +10253,8 @@
          /*<<set.ml:195:32>>*/ }
         function remove_min_elt(param){
           /*<<set.ml:199:29>>*/ if(! param)
-           /*<<set.ml:200:17>>*/ return caml_call1
-                  (Stdlib[1], cst_Set_remove_min_elt) /*<<set.ml:202:51>>*/ ;
+           /*<<set.ml:200:17>>*/ return Stdlib[1].call
+                  (null, cst_Set_remove_min_elt) /*<<set.ml:202:51>>*/ ;
          var l =  /*<<set.ml:199:29>>*/ param[1];
          if(l){
           var r = param[3], v = param[2];
@@ -10980,7 +10881,7 @@
                       (x1,  /*<<set.ml:586:51>>*/ singleton(x0)))) /*<<set.ml:588:58>>*/ ;
           /*<<set.ml:581:6>>*/ if(match$2[2]){
           var
-           l$0 =  /*<<set.ml:588:28>>*/ caml_call2(Stdlib_List[66], Ord[1], l),
+           l$0 =  /*<<set.ml:588:28>>*/ Stdlib_List[66].call(null, Ord[1], l),
            sub =
               /*<<set.ml:558:6>>*/ function(n, l){
                /*<<set.ml:559:8>>*/ if(3 >= n >>> 0)
@@ -11039,8 +10940,7 @@
                /*<<set.ml:574:12>>*/ return [0, create(left, mid, right), l$2] /*<<set.ml:574:33>>*/ ;
               /*<<set.ml:574:36>>*/ };
            /*<<set.ml:576:15>>*/ return  /*<<set.ml:576:10>>*/ sub
-                   ( /*<<set.ml:576:15>>*/ caml_call1(Stdlib_List[1], l$0),
-                    l$0)
+                   ( /*<<set.ml:576:15>>*/ Stdlib_List[1].call(null, l$0), l$0)
                   [1] /*<<set.ml:576:33>>*/ ;
          }
          var x4 =  /*<<set.ml:581:6>>*/ match$2[1];
@@ -11054,8 +10954,8 @@
                        (x1,  /*<<set.ml:587:63>>*/ singleton(x0))))) /*<<set.ml:588:58>>*/ ;
         }
         function add_seq(i, m){
-          /*<<set.ml:591:6>>*/ return caml_call3
-                 (Stdlib_Seq[5],
+          /*<<set.ml:591:6>>*/ return Stdlib_Seq[5].call
+                 (null,
                   function(s, x){
                     /*<<set.ml:591:32>>*/ return add(x, s) /*<<set.ml:591:39>>*/ ;
                   },
@@ -11257,7 +11157,7 @@
           var hr =  /*<<map.ml:93:37>>*/ 0;
           /*<<map.ml:94:6>>*/ if((hr + 2 | 0) < hl){
            /*<<map.ml:94:26>>*/ if(! l)
-            /*<<map.ml:96:19>>*/ return caml_call1(Stdlib[1], cst_Map_bal$0) /*<<map.ml:119:67>>*/ ;
+            /*<<map.ml:96:19>>*/ return Stdlib[1].call(null, cst_Map_bal$0) /*<<map.ml:119:67>>*/ ;
           var
            lr =  /*<<map.ml:94:26>>*/ l[4],
            ld = l[3],
@@ -11268,7 +11168,7 @@
             /*<<map.ml:99:30>>*/ return  /*<<map.ml:99:47>>*/ create
                    (ll, lv, ld,  /*<<map.ml:99:30>>*/ create(lr, x, d, r)) /*<<map.ml:119:67>>*/ ;
            /*<<map.ml:100:17>>*/ if(! lr)
-            /*<<map.ml:102:25>>*/ return caml_call1(Stdlib[1], cst_Map_bal) /*<<map.ml:119:67>>*/ ;
+            /*<<map.ml:102:25>>*/ return Stdlib[1].call(null, cst_Map_bal) /*<<map.ml:119:67>>*/ ;
           var
            lrr =  /*<<map.ml:100:17>>*/ lr[4],
            lrd = lr[3],
@@ -11286,7 +11186,7 @@
           return [0, l, x, d, r, _w_];
          }
           /*<<map.ml:106:35>>*/ if(! r)
-           /*<<map.ml:108:19>>*/ return caml_call1(Stdlib[1], cst_Map_bal$2) /*<<map.ml:119:67>>*/ ;
+           /*<<map.ml:108:19>>*/ return Stdlib[1].call(null, cst_Map_bal$2) /*<<map.ml:119:67>>*/ ;
          var
           rr =  /*<<map.ml:106:35>>*/ r[4],
           rd = r[3],
@@ -11297,7 +11197,7 @@
            /*<<map.ml:111:21>>*/ return  /*<<map.ml:111:38>>*/ create
                   ( /*<<map.ml:111:21>>*/ create(l, x, d, rl), rv, rd, rr) /*<<map.ml:119:67>>*/ ;
           /*<<map.ml:112:17>>*/ if(! rl)
-           /*<<map.ml:114:25>>*/ return caml_call1(Stdlib[1], cst_Map_bal$1) /*<<map.ml:119:67>>*/ ;
+           /*<<map.ml:114:25>>*/ return Stdlib[1].call(null, cst_Map_bal$1) /*<<map.ml:119:67>>*/ ;
          var
           rlr =  /*<<map.ml:112:17>>*/ rl[4],
           rld = rl[3],
@@ -11565,8 +11465,8 @@
          /*<<map.ml:252:37>>*/ }
         function remove_min_binding(param){
           /*<<map.ml:254:33>>*/ if(! param)
-           /*<<map.ml:255:17>>*/ return caml_call1
-                  (Stdlib[1], cst_Map_remove_min_elt) /*<<map.ml:257:61>>*/ ;
+           /*<<map.ml:255:17>>*/ return Stdlib[1].call
+                  (null, cst_Map_remove_min_elt) /*<<map.ml:257:61>>*/ ;
          var l =  /*<<map.ml:254:33>>*/ param[1];
          if(l){
           var r = param[4], d = param[3], v = param[2];
@@ -12083,8 +11983,8 @@
           /*<<map.ml:502:6>>*/ return bindings_aux(0, s) /*<<map.ml:502:23>>*/ ;
         }
         function of_list(bs){
-          /*<<map.ml:509:21>>*/ return caml_call3
-                 (Stdlib_List[26],
+          /*<<map.ml:509:21>>*/ return Stdlib_List[26].call
+                 (null,
                   function(m, param){
                    var v =  /*<<map.ml:509:36>>*/ param[2], k = param[1];
                     /*<<map.ml:509:53>>*/ return add(k, v, m) /*<<map.ml:509:63>>*/ ;
@@ -12093,8 +11993,8 @@
                   bs) /*<<map.ml:509:72>>*/ ;
         }
         function add_seq(i, m){
-          /*<<map.ml:512:6>>*/ return caml_call3
-                 (Stdlib_Seq[5],
+          /*<<map.ml:512:6>>*/ return Stdlib_Seq[5].call
+                 (null,
                   function(m, param){
                    var v =  /*<<map.ml:512:20>>*/ param[2], k = param[1];
                     /*<<map.ml:512:36>>*/ return add(k, v, m) /*<<map.ml:512:46>>*/ ;
@@ -12235,29 +12135,13 @@
 
 //# unitInfo: Provides: Stdlib__Stack
 //# unitInfo: Requires: Stdlib__List, Stdlib__Seq
-//# shape: Stdlib__Stack:[N,F(1)*,F(2),F(1),F(1),F(1),F(1),F(1)*,F(1),F(1)*,F(1)*,F(1)*,F(2),F(3),F(1),F(2),F(1)]
+//# shape: Stdlib__Stack:[N,F(1)*,F(2),F(1),F(1),F(1),F(1),F(1)*,F(1),F(1)*,F(1)*,F(1)*,F(2),F(3),F(1)*,F(2),F(1)]
 (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
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Seq = global_data.Stdlib__Seq,
     Stdlib_List = global_data.Stdlib__List,
@@ -12324,17 +12208,17 @@
      /*<<stack.ml:55:15>>*/ return s[2];
     /*<<stack.ml:55:20>>*/ }
    function iter(f, s){
-     /*<<stack.ml:57:15>>*/ return caml_call2(Stdlib_List[18], f, s[1]) /*<<stack.ml:57:30>>*/ ;
+     /*<<stack.ml:57:15>>*/ return Stdlib_List[18].call(null, f, s[1]) /*<<stack.ml:57:30>>*/ ;
    }
    function fold(f, acc, s){
-     /*<<stack.ml:59:19>>*/ return caml_call3(Stdlib_List[26], f, acc, s[1]) /*<<stack.ml:59:43>>*/ ;
+     /*<<stack.ml:59:19>>*/ return Stdlib_List[26].call(null, f, acc, s[1]) /*<<stack.ml:59:43>>*/ ;
    }
    function to_seq(s){
-     /*<<stack.ml:63:15>>*/ return caml_call1(Stdlib_List[68], s[1]) /*<<stack.ml:63:30>>*/ ;
+     /*<<stack.ml:63:15>>*/ return Stdlib_List[68].call(null, s[1]) /*<<stack.ml:63:30>>*/ ;
    }
    function add_seq(q, i){
-     /*<<stack.ml:65:18>>*/ return caml_call2
-            (Stdlib_Seq[4],
+     /*<<stack.ml:65:18>>*/ return Stdlib_Seq[4].call
+            (null,
              function(x){
                /*<<stack.ml:65:37>>*/ return push(x, q) /*<<stack.ml:65:45>>*/ ;
              },
@@ -12546,8 +12430,8 @@
       /*<<?>>*/ return aux(_a_, _b_);} /*<<queue.ml:166:2>>*/ ;
     /*<<queue.ml:166:13>>*/ }
    function add_seq(q, i){
-     /*<<queue.ml:168:18>>*/ return caml_call2
-            (Stdlib_Seq[4],
+     /*<<queue.ml:168:18>>*/ return Stdlib_Seq[4].call
+            (null,
              function(x){
                /*<<queue.ml:168:37>>*/ return add(x, q) /*<<queue.ml:168:45>>*/ ;
              },
@@ -12615,26 +12499,6 @@
             ? 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,
@@ -12656,19 +12520,19 @@
      /*<<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>>*/ ;
+     /*<<buffer.ml:46:17>>*/ return Stdlib_Bytes[8].call
+            (null, 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>>*/ ;
+     /*<<buffer.ml:47:17>>*/ return Stdlib_Bytes[7].call
+            (null, 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 caml_call3
-             (Stdlib_Bytes[8], b[1][1], ofs, len) /*<<buffer.ml:52:46>>*/ ;
-     /*<<buffer.ml:51:7>>*/ return caml_call1(Stdlib[1], cst_Buffer_sub) /*<<buffer.ml:52:46>>*/ ;
+      /*<<buffer.ml:52:7>>*/ return Stdlib_Bytes[8].call
+             (null, b[1][1], ofs, len) /*<<buffer.ml:52:46>>*/ ;
+     /*<<buffer.ml:51:7>>*/ return Stdlib[1].call(null, cst_Buffer_sub) /*<<buffer.ml:52:46>>*/ ;
    }
    function blit(src, srcoff, dst, dstoff, len){
      /*<<buffer.ml:56:2>>*/ if
@@ -12678,9 +12542,9 @@
        &&
         (src[2] - len | 0) >= srcoff
         && 0 <= dstoff && (caml_ml_bytes_length(dst) - len | 0) >= dstoff)
-      /*<<buffer.ml:60:4>>*/ return caml_call5
-             (Stdlib_Bytes[11], src[1][1], srcoff, dst, dstoff, len) /*<<buffer.ml:60:53>>*/ ;
-     /*<<buffer.ml:58:7>>*/ return caml_call1(Stdlib[1], cst_Buffer_blit) /*<<buffer.ml:60:53>>*/ ;
+      /*<<buffer.ml:60:4>>*/ return Stdlib_Bytes[11].call
+             (null, src[1][1], srcoff, dst, dstoff, len) /*<<buffer.ml:60:53>>*/ ;
+     /*<<buffer.ml:58:7>>*/ return Stdlib[1].call(null, cst_Buffer_blit) /*<<buffer.ml:60:53>>*/ ;
    }
    function nth(b, ofs){
     var
@@ -12691,7 +12555,7 @@
      /*<<buffer.ml:66:2>>*/ if
      (0 <= ofs && position > ofs && length >= position)
       /*<<buffer.ml:68:7>>*/ return runtime.caml_bytes_unsafe_get(buffer, ofs) /*<<buffer.ml:68:34>>*/ ;
-     /*<<buffer.ml:67:3>>*/ return caml_call1(Stdlib[1], cst_Buffer_nth) /*<<buffer.ml:68:34>>*/ ;
+     /*<<buffer.ml:67:3>>*/ return Stdlib[1].call(null, cst_Buffer_nth) /*<<buffer.ml:68:34>>*/ ;
    }
    function length(b){
      /*<<buffer.ml:71:15>>*/ return b[2];
@@ -12719,11 +12583,11 @@
       /*<<buffer.ml:91:43>>*/ if((old_pos + more | 0) <= Stdlib_Sys[12])
        /*<<buffer.ml:93:9>>*/ new_len[1] = Stdlib_Sys[12];
      else
-       /*<<buffer.ml:94:9>>*/ caml_call1
-       (Stdlib[2], cst_Buffer_add_cannot_grow_buf);
+       /*<<buffer.ml:94:9>>*/ Stdlib[2].call
+       (null, cst_Buffer_add_cannot_grow_buf);
     var new_buffer =  /*<<buffer.ml:96:19>>*/ caml_create_bytes(new_len[1]);
-     /*<<buffer.ml:99:2>>*/ caml_call5
-     (Stdlib_Bytes[11], b[1][1], 0, new_buffer, 0, b[2]);
+     /*<<buffer.ml:99:2>>*/ Stdlib_Bytes[11].call
+     (null, b[1][1], 0, new_buffer, 0, b[2]);
      /*<<buffer.ml:99:53>>*/ b[1] = [0, new_buffer, new_len[1]];
     /*<<buffer.ml:100:55>>*/ }
    function add_char(b, c){
@@ -12756,8 +12620,7 @@
        /*<<buffer.ml:127:32>>*/ resize(b, uchar_utf_8_byte_length_max);
      var
       n =
-         /*<<buffer.ml:128:10>>*/ caml_call3
-         (Stdlib_Bytes[51], b[1][1], pos, u);
+         /*<<buffer.ml:128:10>>*/ Stdlib_Bytes[51].call(null, b[1][1], pos, u);
       /*<<buffer.ml:129:2>>*/ if(0 !== n){
        /*<<buffer.ml:131:7>>*/ b[2] = pos + n | 0;
       return 0;
@@ -12772,8 +12635,7 @@
        /*<<buffer.ml:135:32>>*/ resize(b, uchar_utf_16_byte_length_max);
      var
       n =
-         /*<<buffer.ml:136:10>>*/ caml_call3
-         (Stdlib_Bytes[54], b[1][1], pos, u);
+         /*<<buffer.ml:136:10>>*/ Stdlib_Bytes[54].call(null, b[1][1], pos, u);
       /*<<buffer.ml:137:2>>*/ if(0 !== n){
        /*<<buffer.ml:139:7>>*/ b[2] = pos + n | 0;
       return 0;
@@ -12788,8 +12650,7 @@
        /*<<buffer.ml:143:32>>*/ resize(b, uchar_utf_16_byte_length_max);
      var
       n =
-         /*<<buffer.ml:144:10>>*/ caml_call3
-         (Stdlib_Bytes[57], b[1][1], pos, u);
+         /*<<buffer.ml:144:10>>*/ Stdlib_Bytes[57].call(null, b[1][1], pos, u);
       /*<<buffer.ml:145:2>>*/ if(0 !== n){
        /*<<buffer.ml:147:7>>*/ b[2] = pos + n | 0;
       return 0;
@@ -12806,7 +12667,7 @@
       _j_ = len < 0 ? 1 : 0,
       _i_ = _j_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0);
     if(_i_)
-      /*<<buffer.ml:151:7>>*/ caml_call1(Stdlib[1], cst_Buffer_add_substring);
+      /*<<buffer.ml:151:7>>*/ Stdlib[1].call(null, cst_Buffer_add_substring);
     var
      position =  /*<<buffer.ml:152:2>>*/ b[2],
      match =  /*<<buffer.ml:153:2>>*/ b[1],
@@ -12815,8 +12676,8 @@
      new_position =  /*<<buffer.ml:154:2>>*/ position + len | 0;
      /*<<buffer.ml:155:2>>*/ if(length < new_position){
       /*<<buffer.ml:156:4>>*/ resize(b, len);
-      /*<<buffer.ml:157:4>>*/ caml_call5
-      (Stdlib_Bytes[12], s, offset, b[1][1], b[2], len);
+      /*<<buffer.ml:157:4>>*/ Stdlib_Bytes[12].call
+      (null, s, offset, b[1][1], b[2], len);
     }
     else
       /*<<buffer.ml:159:4>>*/ runtime.caml_blit_string
@@ -12833,7 +12694,7 @@
       _h_ = len < 0 ? 1 : 0,
       _g_ = _h_ || ((caml_ml_bytes_length(bytes) - len | 0) < offset ? 1 : 0);
     if(_g_)
-      /*<<buffer.ml:164:7>>*/ caml_call1(Stdlib[1], cst_Buffer_add_subbytes);
+      /*<<buffer.ml:164:7>>*/ Stdlib[1].call(null, cst_Buffer_add_subbytes);
     var
      position =  /*<<buffer.ml:165:2>>*/ b[2],
      match =  /*<<buffer.ml:166:2>>*/ b[1],
@@ -12842,8 +12703,8 @@
      new_position =  /*<<buffer.ml:167:2>>*/ position + len | 0;
      /*<<buffer.ml:168:2>>*/ if(length < new_position){
       /*<<buffer.ml:169:4>>*/ resize(b, len);
-      /*<<buffer.ml:170:4>>*/ caml_call5
-      (Stdlib_Bytes[11], bytes, offset, b[1][1], b[2], len);
+      /*<<buffer.ml:170:4>>*/ Stdlib_Bytes[11].call
+      (null, bytes, offset, b[1][1], b[2], len);
     }
     else
       /*<<buffer.ml:172:4>>*/ runtime.caml_blit_bytes
@@ -12867,7 +12728,7 @@
      _e_ =  /*<<buffer.ml:208:2>>*/ to_read$1 < 0 ? 1 : 0,
      _f_ = _e_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0);
     if(_f_)
-      /*<<buffer.ml:209:4>>*/ caml_call1(Stdlib[1], cst_Buffer_add_channel);
+      /*<<buffer.ml:209:4>>*/ Stdlib[1].call(null, cst_Buffer_add_channel);
      /*<<buffer.ml:202:2>>*/ if(b[1][2] < (b[2] + to_read$1 | 0))
       /*<<buffer.ml:202:44>>*/ resize(b, to_read$1);
     var
@@ -12880,8 +12741,8 @@
       /*<<buffer.ml:187:4>>*/ if(0 !== to_read){
       var
        r =
-          /*<<buffer.ml:189:14>>*/ caml_call4
-          (Stdlib[84], ic, buf, ofs, to_read);
+          /*<<buffer.ml:189:14>>*/ Stdlib[84].call
+          (null, ic, buf, ofs, to_read);
        /*<<buffer.ml:190:6>>*/ if(0 !== r){
        var
         already_read$0 =  /*<<buffer.ml:191:11>>*/ already_read + r | 0,
@@ -12901,8 +12762,8 @@
     }
     /*<<buffer.ml:214:4>>*/ }
    function output_buffer(oc, b){
-     /*<<buffer.ml:217:2>>*/ return caml_call4
-            (Stdlib[68], oc, b[1][1], 0, b[2]) /*<<buffer.ml:217:39>>*/ ;
+     /*<<buffer.ml:217:2>>*/ return Stdlib[68].call
+            (null, oc, b[1][1], 0, b[2]) /*<<buffer.ml:217:39>>*/ ;
    }
    function add_substitute(b, f, s){
     var
@@ -12961,8 +12822,8 @@
           var
            val =
               /*<<buffer.ml:258:38>>*/ [0,
-               /*<<buffer.ml:258:5>>*/ caml_call3
-               (Stdlib_String[16], s, start, stop$0 - start | 0),
+               /*<<buffer.ml:258:5>>*/ Stdlib_String[16].call
+               (null, s, start, stop$0 - start | 0),
               stop$0];
           break a;
          }
@@ -13002,8 +12863,8 @@
          var
           val =
              /*<<buffer.ml:253:46>>*/ [0,
-              /*<<buffer.ml:253:5>>*/ caml_call3
-              (Stdlib_String[16], s, new_start, (stop - start | 0) - 1 | 0),
+              /*<<buffer.ml:253:5>>*/ Stdlib_String[16].call
+              (null, s, new_start, (stop - start | 0) - 1 | 0),
              stop + 1 | 0];
         }
        }
@@ -13037,7 +12898,7 @@
       /*<<buffer.ml:292:6>>*/ b[2] = len;
      return 0;
     }
-     /*<<buffer.ml:290:6>>*/ return caml_call1(Stdlib[1], cst_Buffer_truncate) /*<<buffer.ml:292:23>>*/ ;
+     /*<<buffer.ml:290:6>>*/ return Stdlib[1].call(null, cst_Buffer_truncate) /*<<buffer.ml:292:23>>*/ ;
    }
    function to_seq(b){
     function aux(i, param){
@@ -13070,8 +12931,8 @@
       /*<<?>>*/ return aux(_a_, _b_);} /*<<buffer.ml:314:2>>*/ ;
     /*<<buffer.ml:314:7>>*/ }
    function add_seq(b, seq){
-     /*<<buffer.ml:316:41>>*/ return caml_call2
-            (Stdlib_Seq[4],
+     /*<<buffer.ml:316:41>>*/ return Stdlib_Seq[4].call
+            (null,
              function(_a_){ /*<<buffer.ml:316:29>>*/ return add_char(b, _a_);},
              seq) /*<<buffer.ml:316:45>>*/ ;
    }
@@ -13308,18 +13169,7 @@
    "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
+    caml_maybe_attach_backtrace = runtime.caml_maybe_attach_backtrace,
     global_data = runtime.caml_get_global_data(),
     Stdlib_Mutex = global_data.Stdlib__Mutex,
     Stdlib_Condition = global_data.Stdlib__Condition,
@@ -13329,41 +13179,41 @@
     cst_Semaphore_Counting_release = "Semaphore.Counting.release: overflow";
    function make(v){
      /*<<semaphore.ml:29:2>>*/ if(v < 0)
-      /*<<semaphore.ml:29:16>>*/ caml_call1
-      (Stdlib[1], cst_Semaphore_Counting_init_wr);
-    var _b_ =  /*<<semaphore.ml:30:39>>*/ caml_call1(Stdlib_Condition[1], 0);
+      /*<<semaphore.ml:29:16>>*/ Stdlib[1].call
+      (null, cst_Semaphore_Counting_init_wr);
+    var _b_ =  /*<<semaphore.ml:30:39>>*/ Stdlib_Condition[1].call(null, 0);
      /*<<semaphore.ml:30:10>>*/ return [0,
-            caml_call1(Stdlib_Mutex[1], 0),
+            Stdlib_Mutex[1].call(null, 0),
             v,
             _b_] /*<<semaphore.ml:30:24>>*/ ;
     /*<<semaphore.ml:30:59>>*/ }
    function release(s){
-     /*<<semaphore.ml:33:2>>*/ caml_call1(Stdlib_Mutex[2], s[1]);
+     /*<<semaphore.ml:33:2>>*/ Stdlib_Mutex[2].call(null, s[1]);
      /*<<semaphore.ml:33:18>>*/ if(s[2] < Stdlib[19]){
       /*<<semaphore.ml:34:24>>*/ s[2] = s[2] + 1 | 0;
-      /*<<semaphore.ml:36:4>>*/ caml_call1(Stdlib_Condition[3], s[3]);
-      /*<<semaphore.ml:36:30>>*/ return caml_call1(Stdlib_Mutex[4], s[1]) /*<<semaphore.ml:41:5>>*/ ;
+      /*<<semaphore.ml:36:4>>*/ Stdlib_Condition[3].call(null, s[3]);
+      /*<<semaphore.ml:36:30>>*/ return Stdlib_Mutex[4].call(null, s[1]) /*<<semaphore.ml:41:5>>*/ ;
     }
-     /*<<semaphore.ml:39:4>>*/ caml_call1(Stdlib_Mutex[4], s[1]);
+     /*<<semaphore.ml:39:4>>*/ Stdlib_Mutex[4].call(null, s[1]);
      /*<<semaphore.ml:39:22>>*/ throw caml_maybe_attach_backtrace
            ([0, Stdlib[11], cst_Semaphore_Counting_release], 1);
     /*<<semaphore.ml:41:5>>*/ }
    function acquire(s){
-     /*<<semaphore.ml:44:2>>*/ caml_call1(Stdlib_Mutex[2], s[1]);
+     /*<<semaphore.ml:44:2>>*/ Stdlib_Mutex[2].call(null, s[1]);
      /*<<semaphore.ml:44:18>>*/ for(;;){
      if(0 !== s[2]){
        /*<<semaphore.ml:46:2>>*/ s[2] = s[2] - 1 | 0;
-       /*<<semaphore.ml:47:2>>*/ return caml_call1(Stdlib_Mutex[4], s[1]) /*<<semaphore.ml:47:20>>*/ ;
+       /*<<semaphore.ml:47:2>>*/ return Stdlib_Mutex[4].call(null, s[1]) /*<<semaphore.ml:47:20>>*/ ;
      }
-      /*<<semaphore.ml:45:19>>*/ caml_call2(Stdlib_Condition[2], s[3], s[1]);
+      /*<<semaphore.ml:45:19>>*/ Stdlib_Condition[2].call(null, s[3], s[1]);
     }
     /*<<semaphore.ml:47:20>>*/ }
    function try_acquire(s){
-     /*<<semaphore.ml:50:2>>*/ caml_call1(Stdlib_Mutex[2], s[1]);
+     /*<<semaphore.ml:50:2>>*/ Stdlib_Mutex[2].call(null, s[1]);
     var
      ret =
         /*<<semaphore.ml:50:18>>*/ 0 === s[2] ? 0 : (s[2] = s[2] - 1 | 0, 1);
-     /*<<semaphore.ml:52:2>>*/ caml_call1(Stdlib_Mutex[4], s[1]);
+     /*<<semaphore.ml:52:2>>*/ Stdlib_Mutex[4].call(null, s[1]);
      /*<<semaphore.ml:52:20>>*/ return ret;
     /*<<semaphore.ml:53:5>>*/ }
    function get_value(s){
@@ -13373,33 +13223,33 @@
     Counting =  /*<<?>>*/ [0, make, release, acquire, try_acquire, get_value];
    function make$0(b){
     var
-     _a_ =  /*<<semaphore.ml:66:14>>*/ caml_call1(Stdlib_Condition[1], 0),
+     _a_ =  /*<<semaphore.ml:66:14>>*/ Stdlib_Condition[1].call(null, 0),
      _b_ =  /*<<semaphore.ml:66:32>>*/ b ? 1 : 0;
      /*<<semaphore.ml:64:10>>*/ return [0,
-            caml_call1(Stdlib_Mutex[1], 0),
+            Stdlib_Mutex[1].call(null, 0),
             _b_,
             _a_] /*<<semaphore.ml:64:24>>*/ ;
     /*<<semaphore.ml:66:34>>*/ }
    function release$0(s){
-     /*<<semaphore.ml:69:2>>*/ caml_call1(Stdlib_Mutex[2], s[1]);
+     /*<<semaphore.ml:69:2>>*/ Stdlib_Mutex[2].call(null, s[1]);
      /*<<semaphore.ml:69:18>>*/ s[2] = 1;
-     /*<<semaphore.ml:71:2>>*/ caml_call1(Stdlib_Condition[3], s[3]);
-     /*<<semaphore.ml:71:28>>*/ return caml_call1(Stdlib_Mutex[4], s[1]) /*<<semaphore.ml:72:20>>*/ ;
+     /*<<semaphore.ml:71:2>>*/ Stdlib_Condition[3].call(null, s[3]);
+     /*<<semaphore.ml:71:28>>*/ return Stdlib_Mutex[4].call(null, s[1]) /*<<semaphore.ml:72:20>>*/ ;
    }
    function acquire$0(s){
-     /*<<semaphore.ml:75:2>>*/ caml_call1(Stdlib_Mutex[2], s[1]);
+     /*<<semaphore.ml:75:2>>*/ Stdlib_Mutex[2].call(null, s[1]);
      /*<<semaphore.ml:75:18>>*/ for(;;){
      if(0 !== s[2]){
        /*<<semaphore.ml:77:2>>*/ s[2] = 0;
-       /*<<semaphore.ml:78:2>>*/ return caml_call1(Stdlib_Mutex[4], s[1]) /*<<semaphore.ml:78:20>>*/ ;
+       /*<<semaphore.ml:78:2>>*/ return Stdlib_Mutex[4].call(null, s[1]) /*<<semaphore.ml:78:20>>*/ ;
      }
-      /*<<semaphore.ml:76:19>>*/ caml_call2(Stdlib_Condition[2], s[3], s[1]);
+      /*<<semaphore.ml:76:19>>*/ Stdlib_Condition[2].call(null, s[3], s[1]);
     }
     /*<<semaphore.ml:78:20>>*/ }
    function try_acquire$0(s){
-     /*<<semaphore.ml:81:2>>*/ caml_call1(Stdlib_Mutex[2], s[1]);
+     /*<<semaphore.ml:81:2>>*/ Stdlib_Mutex[2].call(null, s[1]);
     var ret =  /*<<semaphore.ml:81:18>>*/ 0 === s[2] ? 0 : (s[2] = 0, 1);
-     /*<<semaphore.ml:83:2>>*/ caml_call1(Stdlib_Mutex[4], s[1]);
+     /*<<semaphore.ml:83:2>>*/ Stdlib_Mutex[4].call(null, s[1]);
      /*<<semaphore.ml:83:20>>*/ return ret;
     /*<<semaphore.ml:84:5>>*/ }
    var
@@ -13429,21 +13279,6 @@
             ? 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
     dummy = 0,
     global_data = runtime.caml_get_global_data(),
@@ -13464,13 +13299,13 @@
     /*<<domain.ml:90:20>>*/ }
     /*<<domain.ml:92:10>>*/ create_dls(0);
    var
-    key_counter =  /*<<domain.ml:96:20>>*/ caml_call1(Stdlib_Atomic[1], 0),
-    parent_keys =  /*<<domain.ml:101:20>>*/ caml_call1(Stdlib_Atomic[1], 0),
+    key_counter =  /*<<domain.ml:96:20>>*/ Stdlib_Atomic[1].call(null, 0),
+    parent_keys =  /*<<domain.ml:101:20>>*/ Stdlib_Atomic[1].call(null, 0),
     _a_ =  /*<<domain.ml:101:59>>*/ [0, "domain.ml", 184, 13];
    function new_key(split_from_parent, init_orphan){
     var
      idx =
-        /*<<domain.ml:109:14>>*/ caml_call2(Stdlib_Atomic[7], key_counter, 1),
+        /*<<domain.ml:109:14>>*/ Stdlib_Atomic[7].call(null, key_counter, 1),
      k =  /*<<domain.ml:110:4>>*/ [0, idx, init_orphan];
      /*<<domain.ml:111:4>>*/ if(split_from_parent){
      var
@@ -13478,9 +13313,9 @@
       ki =  /*<<domain.ml:113:20>>*/ [0, k, split];
      for(;;){
       var
-       l =  /*<<domain.ml:104:12>>*/ caml_call1(Stdlib_Atomic[3], parent_keys);
+       l =  /*<<domain.ml:104:12>>*/ Stdlib_Atomic[3].call(null, parent_keys);
        /*<<domain.ml:105:11>>*/ if
-       (! (1 - caml_call3(Stdlib_Atomic[6], parent_keys, l, [0, ki, l])))
+       (! (1 - Stdlib_Atomic[6].call(null, parent_keys, l, [0, ki, l])))
        break;
      }
     }
@@ -13500,8 +13335,7 @@
       new_sz = s;
      }
      var new_st =  /*<<domain.ml:128:19>>*/ caml_array_make(new_sz, none);
-      /*<<domain.ml:129:6>>*/ caml_call5
-      (Stdlib_Array[9], st, 0, new_st, 0, sz);
+      /*<<domain.ml:129:6>>*/ Stdlib_Array[9].call(null, st, 0, new_st, 0, sz);
       /*<<domain.ml:136:9>>*/ if
       (runtime.caml_domain_dls_compare_and_set(st, new_st))
        /*<<domain.ml:137:11>>*/ return new_st;
@@ -13541,8 +13375,8 @@
            ([0, Assert_failure, _a_], 1);
     /*<<domain.ml:186:7>>*/ }
    function set_initial_keys(l){
-     /*<<domain.ml:196:4>>*/ return caml_call2
-            (Stdlib_List[18],
+     /*<<domain.ml:196:4>>*/ return Stdlib_List[18].call
+            (null,
              function(param){
               var v =  /*<<domain.ml:196:14>>*/ param[2], k = param[1];
                /*<<domain.ml:196:34>>*/ return set(k, v) /*<<domain.ml:196:42>>*/ ;
@@ -13561,7 +13395,7 @@
     /*<<domain.ml:205:44>>*/ }
    var
     first_domain_spawned =
-       /*<<domain.ml:213:27>>*/ caml_call1(Stdlib_Atomic[1], 0),
+       /*<<domain.ml:213:27>>*/ Stdlib_Atomic[1].call(null, 0),
     first_spawn_function =
        /*<<domain.ml:213:44>>*/ [0,
        function(param){ /*<<domain.ml:215:44>>*/ }],
@@ -13569,7 +13403,7 @@
        /*<<domain.ml:213:44>>*/ "first domain already spawned";
    function before_first_spawn(f){
      /*<<domain.ml:218:5>>*/ if
-     (caml_call1(Stdlib_Atomic[3], first_domain_spawned))
+     (Stdlib_Atomic[3].call(null, first_domain_spawned))
       /*<<domain.ml:219:4>>*/ throw caml_maybe_attach_backtrace
             ([0, Stdlib[6], cst_first_domain_already_spawn], 1);
     var old_f =  /*<<domain.ml:220:7>>*/ first_spawn_function[1];
@@ -13603,9 +13437,9 @@
     /*<<domain.ml:234:56>>*/ Stdlib[104][1] = do_at_exit;
    function spawn(f){
      /*<<domain.ml:227:9>>*/ if
-     (1 - caml_call1(Stdlib_Atomic[3], first_domain_spawned)){
-      /*<<domain.ml:228:4>>*/ caml_call2
-      (Stdlib_Atomic[4], first_domain_spawned, 1);
+     (1 - Stdlib_Atomic[3].call(null, first_domain_spawned)){
+      /*<<domain.ml:228:4>>*/ Stdlib_Atomic[4].call
+      (null, first_domain_spawned, 1);
       /*<<domain.ml:229:4>>*/ caml_call1(first_spawn_function[1], 0);
       /*<<domain.ml:229:27>>*/ first_spawn_function[1] =
       function(param){
@@ -13613,10 +13447,10 @@
        /*<<domain.ml:231:41>>*/ };
     }
     var
-     _a_ =  /*<<domain.ml:193:6>>*/ caml_call1(Stdlib_Atomic[3], parent_keys),
+     _a_ =  /*<<domain.ml:193:6>>*/ Stdlib_Atomic[3].call(null, parent_keys),
      pk =
-        /*<<domain.ml:193:30>>*/ caml_call2
-        (Stdlib_List[20],
+        /*<<domain.ml:193:30>>*/ Stdlib_List[20].call
+        (null,
          function(param){
           var split =  /*<<domain.ml:192:6>>*/ param[2], k = param[1];
            /*<<domain.ml:192:44>>*/ return [0,
@@ -13625,9 +13459,9 @@
                    (split,  /*<<domain.ml:192:44>>*/ get(k))] /*<<domain.ml:192:52>>*/ ;
           /*<<domain.ml:192:54>>*/ },
          _a_),
-     _b_ =  /*<<domain.ml:259:17>>*/ caml_call1(Stdlib_Condition[1], 0),
+     _b_ =  /*<<domain.ml:259:17>>*/ Stdlib_Condition[1].call(null, 0),
      term_sync =
-        /*<<domain.ml:258:16>>*/ [0, 0, caml_call1(Stdlib_Mutex[1], 0), _b_];
+        /*<<domain.ml:258:16>>*/ [0, 0, Stdlib_Mutex[1].call(null, 0), _b_];
     function body(param){
       /*<<domain.ml:263:4>>*/ try{
        /*<<domain.ml:264:6>>*/ create_dls(0);
@@ -13653,14 +13487,13 @@
       /*<<domain.ml:290:4>>*/ for(;;){
       var match = term_sync[1];
       if(match){var res = match[1];  /*<<domain.ml:295:8>>*/ return res;}
-       /*<<domain.ml:292:8>>*/ caml_call2
-       (Stdlib_Condition[2], term_sync[3], term_sync[2]);
+       /*<<domain.ml:292:8>>*/ Stdlib_Condition[2].call
+       (null, term_sync[3], term_sync[2]);
      }
      /*<<domain.ml:295:11>>*/ }
     var
      match =
-        /*<<domain.ml:297:8>>*/ caml_call2
-        (Stdlib_Mutex[5], term_sync[2], loop);
+        /*<<domain.ml:297:8>>*/ Stdlib_Mutex[5].call(null, term_sync[2], loop);
      /*<<domain.ml:297:40>>*/ if(0 === match[0]){
      var x = match[1];
       /*<<domain.ml:298:12>>*/ return x;
@@ -13854,8 +13687,8 @@
     _p_ = [0, cst_camlinternalFormat_ml, 826, 22],
     _q_ = [0, cst_camlinternalFormat_ml, 831, 30];
    function create_char_set(param){
-     /*<<camlinternalFormat.ml:24:25>>*/ return caml_call2
-            (Stdlib_Bytes[1], 32, 0) /*<<camlinternalFormat.ml:24:45>>*/ ;
+     /*<<camlinternalFormat.ml:24:25>>*/ return Stdlib_Bytes[1].call
+            (null, 32, 0) /*<<camlinternalFormat.ml:24:45>>*/ ;
    }
    function add_in_char_set(char_set, c){
     var
@@ -13868,11 +13701,11 @@
      /*<<camlinternalFormat.ml:31:4>>*/ return  /*<<camlinternalFormat.ml:30:2>>*/ caml_bytes_set
             (char_set,
              str_ind,
-              /*<<camlinternalFormat.ml:31:4>>*/ caml_call1(Stdlib[29], _a7_)) /*<<camlinternalFormat.ml:31:69>>*/ ;
+              /*<<camlinternalFormat.ml:31:4>>*/ Stdlib[29].call(null, _a7_)) /*<<camlinternalFormat.ml:31:69>>*/ ;
    }
    function freeze_char_set(char_set){
-     /*<<camlinternalFormat.ml:34:2>>*/ return caml_call1
-            (Stdlib_Bytes[6], char_set) /*<<camlinternalFormat.ml:34:26>>*/ ;
+     /*<<camlinternalFormat.ml:34:2>>*/ return Stdlib_Bytes[6].call
+            (null, char_set) /*<<camlinternalFormat.ml:34:26>>*/ ;
    }
    function rev_char_set(char_set){
     var
@@ -13886,11 +13719,11 @@
       /*<<camlinternalFormat.ml:41:6>>*/  /*<<camlinternalFormat.ml:40:4>>*/ caml_bytes_set
       (char_set$0,
        i,
-        /*<<camlinternalFormat.ml:41:6>>*/ caml_call1(Stdlib[29], _a6_));
+        /*<<camlinternalFormat.ml:41:6>>*/ Stdlib[29].call(null, _a6_));
      var _a7_ =  /*<<camlinternalFormat.ml:41:67>>*/ i + 1 | 0;
      if(31 === i)
-       /*<<camlinternalFormat.ml:43:2>>*/ return caml_call1
-              (Stdlib_Bytes[44], char_set$0) /*<<camlinternalFormat.ml:43:34>>*/ ;
+       /*<<camlinternalFormat.ml:43:2>>*/ return Stdlib_Bytes[44].call
+              (null, char_set$0) /*<<camlinternalFormat.ml:43:34>>*/ ;
       /*<<camlinternalFormat.ml:41:67>>*/ i = _a7_;
     }
     /*<<camlinternalFormat.ml:43:34>>*/ }
@@ -14009,12 +13842,12 @@
      /*<<camlinternalFormat.ml:262:2>>*/ if(len < min_len){
      var
       new_len =
-         /*<<camlinternalFormat.ml:263:18>>*/ caml_call2
-         (Stdlib_Int[11], len * 2 | 0, min_len),
+         /*<<camlinternalFormat.ml:263:18>>*/ Stdlib_Int[11].call
+         (null, len * 2 | 0, min_len),
       new_str =
          /*<<camlinternalFormat.ml:264:18>>*/ caml_create_bytes(new_len);
-      /*<<camlinternalFormat.ml:265:4>>*/ caml_call5
-      (Stdlib_Bytes[11], buf[2], 0, new_str, 0, len);
+      /*<<camlinternalFormat.ml:265:4>>*/ Stdlib_Bytes[11].call
+      (null, buf[2], 0, new_str, 0, len);
       /*<<camlinternalFormat.ml:265:40>>*/ buf[2] = new_str;
     }
     /*<<camlinternalFormat.ml:267:3>>*/ }
@@ -14027,13 +13860,13 @@
     var
      str_len =  /*<<camlinternalFormat.ml:277:2>>*/ caml_ml_string_length(s);
      /*<<camlinternalFormat.ml:278:2>>*/ buffer_check_size(buf, str_len);
-     /*<<camlinternalFormat.ml:279:2>>*/ caml_call5
-     (Stdlib_String[6], s, 0, buf[2], buf[1], str_len);
+     /*<<camlinternalFormat.ml:279:2>>*/ Stdlib_String[6].call
+     (null, s, 0, buf[2], buf[1], str_len);
      /*<<camlinternalFormat.ml:279:43>>*/ buf[1] = buf[1] + str_len | 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>>*/ ;
+     /*<<camlinternalFormat.ml:284:2>>*/ return Stdlib_Bytes[8].call
+            (null, buf[2], 0, buf[1]) /*<<camlinternalFormat.ml:284:38>>*/ ;
    }
    function char_of_iconv(iconv){
      /*<<camlinternalFormat.ml:289:26>>*/ switch(iconv){
@@ -14081,7 +13914,7 @@
     /*<<camlinternalFormat.ml:301:19>>*/ }
    function bprint_char_set(buf, char_set){
     function print_char(buf, i){
-     var c =  /*<<camlinternalFormat.ml:358:31>>*/ caml_call1(Stdlib[29], i);
+     var c =  /*<<camlinternalFormat.ml:358:31>>*/ Stdlib[29].call(null, i);
       /*<<camlinternalFormat.ml:358:44>>*/ return 37 === c
              ? ( /*<<camlinternalFormat.ml:359:13>>*/ buffer_add_char
                 (buf, 37),
@@ -14105,11 +13938,11 @@
     function is_alone(c){
      var
       after =
-         /*<<camlinternalFormat.ml:316:50>>*/ caml_call1
-         (Stdlib_Char[1], c + 1 | 0),
+         /*<<camlinternalFormat.ml:316:50>>*/ Stdlib_Char[1].call
+         (null, c + 1 | 0),
       before =
-         /*<<camlinternalFormat.ml:316:32>>*/ caml_call1
-         (Stdlib_Char[1], c - 1 | 0),
+         /*<<camlinternalFormat.ml:316:32>>*/ Stdlib_Char[1].call
+         (null, c - 1 | 0),
       _a3_ =  /*<<camlinternalFormat.ml:317:6>>*/ is_in_char_set(set, c);
       /*<<camlinternalFormat.ml:317:26>>*/ if(_a3_)
       var
@@ -14133,15 +13966,14 @@
        /*<<camlinternalFormat.ml:324:28>>*/ if
        (!
          /*<<camlinternalFormat.ml:324:9>>*/ is_in_char_set
-         (set,
-           /*<<camlinternalFormat.ml:324:28>>*/ caml_call1(Stdlib[29], i))){
+         (set,  /*<<camlinternalFormat.ml:324:28>>*/ Stdlib[29].call(null, i))){
        var i$0 =  /*<<camlinternalFormat.ml:325:11>>*/ i + 1 | 0;
        i = i$0;
        continue;
       }
       var
        switcher =
-          /*<<camlinternalFormat.ml:327:10>>*/ caml_call1(Stdlib[29], i) - 45
+          /*<<camlinternalFormat.ml:327:10>>*/ Stdlib[29].call(null, i) - 45
          | 0;
        /*<<camlinternalFormat.ml:327:23>>*/ if(48 < switcher >>> 0){
        if(210 <= switcher){
@@ -14159,7 +13991,7 @@
        (!
          /*<<camlinternalFormat.ml:332:7>>*/ is_in_char_set
          (set,
-           /*<<camlinternalFormat.ml:332:26>>*/ caml_call1(Stdlib[29], i$1))){
+           /*<<camlinternalFormat.ml:332:26>>*/ Stdlib[29].call(null, i$1))){
         /*<<camlinternalFormat.ml:347:6>>*/ print_char(buf, i$1 - 1 | 0);
        var i$6 =  /*<<camlinternalFormat.ml:347:28>>*/ i$1 + 1 | 0;
        i = i$6;
@@ -14167,8 +13999,7 @@
       }
       var
        switcher$0 =
-          /*<<camlinternalFormat.ml:333:12>>*/ caml_call1(Stdlib[29], i$1)
-         - 45
+          /*<<camlinternalFormat.ml:333:12>>*/ Stdlib[29].call(null, i$1) - 45
          | 0;
        /*<<camlinternalFormat.ml:333:25>>*/ if(48 < switcher$0 >>> 0){
        if(210 <= switcher$0){
@@ -14183,8 +14014,8 @@
          !
           /*<<camlinternalFormat.ml:337:27>>*/ is_in_char_set
           (set,
-            /*<<camlinternalFormat.ml:337:47>>*/ caml_call1
-            (Stdlib[29], i$1 + 1 | 0))){
+            /*<<camlinternalFormat.ml:337:47>>*/ Stdlib[29].call
+            (null, i$1 + 1 | 0))){
         /*<<camlinternalFormat.ml:338:8>>*/ print_char(buf, i$1 - 1 | 0);
        var i$5 =  /*<<camlinternalFormat.ml:338:30>>*/ i$1 + 1 | 0;
        i = i$5;
@@ -14194,8 +14025,8 @@
        (!
          /*<<camlinternalFormat.ml:340:19>>*/ is_in_char_set
          (set,
-           /*<<camlinternalFormat.ml:340:39>>*/ caml_call1
-           (Stdlib[29], i$1 + 1 | 0))){
+           /*<<camlinternalFormat.ml:340:39>>*/ Stdlib[29].call
+           (null, i$1 + 1 | 0))){
         /*<<camlinternalFormat.ml:341:8>>*/ print_char(buf, i$1 - 1 | 0);
         /*<<camlinternalFormat.ml:342:8>>*/ print_char(buf, i$1);
        var i$4 =  /*<<camlinternalFormat.ml:342:24>>*/ i$1 + 2 | 0;
@@ -14212,7 +14043,7 @@
         (!
           /*<<camlinternalFormat.ml:351:22>>*/ is_in_char_set
           (set,
-            /*<<camlinternalFormat.ml:351:42>>*/ caml_call1(Stdlib[29], j$0)))
+            /*<<camlinternalFormat.ml:351:42>>*/ Stdlib[29].call(null, j$0)))
         break;
        var j$1 =  /*<<camlinternalFormat.ml:357:6>>*/ j$0 + 1 | 0;
        j$0 = j$1;
@@ -14252,8 +14083,8 @@
     var width =  /*<<camlinternalFormat.ml:385:33>>*/ pad_opt[1];
      /*<<camlinternalFormat.ml:387:40>>*/ return  /*<<camlinternalFormat.ml:387:61>>*/ buffer_add_string
             (buf,
-              /*<<camlinternalFormat.ml:387:40>>*/ caml_call1
-              (Stdlib_Int[12], width)) /*<<camlinternalFormat.ml:387:61>>*/ ;
+              /*<<camlinternalFormat.ml:387:40>>*/ Stdlib_Int[12].call
+              (null, width)) /*<<camlinternalFormat.ml:387:61>>*/ ;
    }
    function bprint_padding(buf, pad){
      /*<<camlinternalFormat.ml:393:15>>*/ if(typeof pad === "number")
@@ -14263,8 +14094,8 @@
       /*<<camlinternalFormat.ml:396:4>>*/ bprint_padty(buf, padty);
       /*<<camlinternalFormat.ml:397:26>>*/ return  /*<<camlinternalFormat.ml:397:43>>*/ buffer_add_string
              (buf,
-               /*<<camlinternalFormat.ml:397:26>>*/ caml_call1
-               (Stdlib_Int[12], n)) /*<<camlinternalFormat.ml:400:27>>*/ ;
+               /*<<camlinternalFormat.ml:397:26>>*/ Stdlib_Int[12].call
+               (null, n)) /*<<camlinternalFormat.ml:400:27>>*/ ;
     }
     var padty$0 =  /*<<camlinternalFormat.ml:393:15>>*/ pad[1];
      /*<<camlinternalFormat.ml:399:4>>*/ bprint_padty(buf, padty$0);
@@ -14276,8 +14107,8 @@
       /*<<camlinternalFormat.ml:407:4>>*/ buffer_add_char(buf, 46);
       /*<<camlinternalFormat.ml:408:26>>*/ return  /*<<camlinternalFormat.ml:408:43>>*/ buffer_add_string
              (buf,
-               /*<<camlinternalFormat.ml:408:26>>*/ caml_call1
-               (Stdlib_Int[12], n)) /*<<camlinternalFormat.ml:410:30>>*/ ;
+               /*<<camlinternalFormat.ml:408:26>>*/ Stdlib_Int[12].call
+               (null, n)) /*<<camlinternalFormat.ml:410:30>>*/ ;
     }
      /*<<camlinternalFormat.ml:404:18>>*/ if(prec)
       /*<<camlinternalFormat.ml:410:4>>*/ return buffer_add_string(buf, cst) /*<<camlinternalFormat.ml:410:30>>*/ ;
@@ -14349,10 +14180,10 @@
        var
         c =  /*<<camlinternalFormat.ml:465:46>>*/ formatting_lit[1],
         _a3_ =
-           /*<<camlinternalFormat.ml:475:26>>*/ caml_call2
-           (Stdlib_String[1], 1, c);
-        /*<<camlinternalFormat.ml:475:43>>*/ return caml_call2
-               (Stdlib[28], cst$7, _a3_);
+           /*<<camlinternalFormat.ml:475:26>>*/ Stdlib_String[1].call
+           (null, 1, c);
+        /*<<camlinternalFormat.ml:475:43>>*/ return Stdlib[28].call
+               (null, cst$7, _a3_);
     }
    }
    function bprint_char_literal(buf, chr){
@@ -15618,8 +15449,9 @@
          var
           fmt$0 =  /*<<camlinternalFormat.ml:856:22>>*/ formatting_gen[1][1],
           _aW_ =  /*<<camlinternalFormat.ml:858:34>>*/ fmtty_of_fmt(fmt$0);
-         /*<<camlinternalFormat.ml:914:53>>*/ return caml_call2
-                (CamlinternalFormatBasics[1], _aW_, _aX_) /*<<camlinternalFormat.ml:916:46>>*/ ;
+         /*<<camlinternalFormat.ml:914:53>>*/ return CamlinternalFormatBasics
+                 [1].call
+                (null, _aW_, _aX_) /*<<camlinternalFormat.ml:916:46>>*/ ;
        case 19:
         var rest$14 =  /*<<camlinternalFormat.ml:863:13>>*/ fmtty[1];
          /*<<camlinternalFormat.ml:897:44>>*/ return [13,
@@ -15651,8 +15483,9 @@
           var
            fmtty$5 = ign[2],
            _aY_ =  /*<<camlinternalFormat.ml:943:58>>*/ fmtty_of_fmt(fmtty$4);
-           /*<<camlinternalFormat.ml:943:76>>*/ return caml_call2
-                  (CamlinternalFormatBasics[1], fmtty$5, _aY_) /*<<camlinternalFormat.ml:916:46>>*/ ;
+           /*<<camlinternalFormat.ml:943:76>>*/ return CamlinternalFormatBasics
+                   [1].call
+                  (null, fmtty$5, _aY_) /*<<camlinternalFormat.ml:916:46>>*/ ;
          }
           /*<<camlinternalFormat.ml:931:15>>*/ fmtty = fmtty$4;
         }
@@ -16251,12 +16084,13 @@
          pad_opt$0 = fmt[1],
          _aW_ =
             /*<<camlinternalFormat.ml:1099:52>>*/ [0,
-            caml_call1(CamlinternalFormatBasics[2], sub_fmtty1)];
+            CamlinternalFormatBasics[2].call(null, sub_fmtty1)];
          /*<<camlinternalFormat.ml:1099:17>>*/ if
          ( /*<<camlinternalFormat.ml:1099:7>>*/ caml_notequal
            ([0,
-              /*<<camlinternalFormat.ml:1099:17>>*/ caml_call1
-              (CamlinternalFormatBasics[2], sub_fmtty$1)],
+              /*<<camlinternalFormat.ml:1099:17>>*/ CamlinternalFormatBasics
+               [2].call
+              (null, sub_fmtty$1)],
             _aW_))
           /*<<camlinternalFormat.ml:1100:6>>*/ throw caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
@@ -16264,8 +16098,9 @@
          match$29 =
             /*<<camlinternalFormat.ml:1102:31>>*/  /*<<camlinternalFormat.ml:1102:6>>*/ type_format_gen
             (fmt_rest$13,
-              /*<<camlinternalFormat.ml:1102:31>>*/ caml_call1
-              (CamlinternalFormatBasics[2], fmtty_rest$10)),
+              /*<<camlinternalFormat.ml:1102:31>>*/ CamlinternalFormatBasics
+               [2].call
+              (null, fmtty_rest$10)),
          fmtty$13 =  /*<<camlinternalFormat.ml:1102:53>>*/ match$29[2],
          fmt$14 = match$29[1];
          /*<<camlinternalFormat.ml:1104:4>>*/ return [0,
@@ -16672,24 +16507,26 @@
          sub1_fmtty$0 = sub_fmtty[1],
          _aU_ =
             /*<<camlinternalFormat.ml:1261:53>>*/ [0,
-            caml_call1(CamlinternalFormatBasics[2], sub1_fmtty)];
+            CamlinternalFormatBasics[2].call(null, sub1_fmtty)];
          /*<<camlinternalFormat.ml:1261:17>>*/ if
          ( /*<<camlinternalFormat.ml:1261:7>>*/ caml_notequal
            ([0,
-              /*<<camlinternalFormat.ml:1261:17>>*/ caml_call1
-              (CamlinternalFormatBasics[2], sub1_fmtty$0)],
+              /*<<camlinternalFormat.ml:1261:17>>*/ CamlinternalFormatBasics
+               [2].call
+              (null, sub1_fmtty$0)],
             _aU_))
           /*<<camlinternalFormat.ml:1262:9>>*/ throw caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
         var
          _aV_ =
             /*<<camlinternalFormat.ml:1263:53>>*/ [0,
-            caml_call1(CamlinternalFormatBasics[2], sub2_fmtty$1)];
+            CamlinternalFormatBasics[2].call(null, sub2_fmtty$1)];
          /*<<camlinternalFormat.ml:1263:17>>*/ if
          ( /*<<camlinternalFormat.ml:1263:7>>*/ caml_notequal
            ([0,
-              /*<<camlinternalFormat.ml:1263:17>>*/ caml_call1
-              (CamlinternalFormatBasics[2], sub2_fmtty$2)],
+              /*<<camlinternalFormat.ml:1263:17>>*/ CamlinternalFormatBasics
+               [2].call
+              (null, sub2_fmtty$2)],
             _aV_))
           /*<<camlinternalFormat.ml:1264:9>>*/ throw caml_maybe_attach_backtrace
                 (Type_mismatch, 1);
@@ -16707,8 +16544,9 @@
         var
          match$9 =
             /*<<camlinternalFormat.ml:1270:39>>*/  /*<<camlinternalFormat.ml:1270:6>>*/ type_ignored_format_substituti
-            ( /*<<camlinternalFormat.ml:1270:39>>*/ caml_call1
-              (CamlinternalFormatBasics[2], sub_fmtty_rest$17),
+            ( /*<<camlinternalFormat.ml:1270:39>>*/ CamlinternalFormatBasics
+               [2].call
+              (null, sub_fmtty_rest$17),
              fmt,
              fmtty_rest$8),
          fmt$9 =  /*<<camlinternalFormat.ml:1270:80>>*/ match$9[2],
@@ -16790,30 +16628,31 @@
     var _aU_ =  /*<<camlinternalFormat.ml:1312:29>>*/ symm(fmtty);
      /*<<camlinternalFormat.ml:1312:18>>*/ return  /*<<camlinternalFormat.ml:1312:42>>*/ type_format
             (fmt,
-              /*<<camlinternalFormat.ml:1312:18>>*/ caml_call1
-              (CamlinternalFormatBasics[2], _aU_)) /*<<camlinternalFormat.ml:1312:42>>*/ ;
+              /*<<camlinternalFormat.ml:1312:18>>*/ CamlinternalFormatBasics
+               [2].call
+              (null, _aU_)) /*<<camlinternalFormat.ml:1312:42>>*/ ;
    }
    function fix_padding(padty, width, str){
     var
      len =  /*<<camlinternalFormat.ml:1319:2>>*/ caml_ml_string_length(str),
      padty$0 =  /*<<camlinternalFormat.ml:1320:2>>*/ 0 <= width ? padty : 0,
      width$0 =
-        /*<<camlinternalFormat.ml:1321:4>>*/ caml_call1(Stdlib[18], width);
+        /*<<camlinternalFormat.ml:1321:4>>*/ Stdlib[18].call(null, width);
      /*<<camlinternalFormat.ml:1332:2>>*/ if(width$0 <= len)
       /*<<camlinternalFormat.ml:1332:23>>*/ return str;
     var
      _aU_ =  /*<<camlinternalFormat.ml:1333:4>>*/ 2 === padty$0 ? 48 : 32,
      res =
-        /*<<camlinternalFormat.ml:1333:14>>*/ caml_call2
-        (Stdlib_Bytes[1], width$0, _aU_);
+        /*<<camlinternalFormat.ml:1333:14>>*/ Stdlib_Bytes[1].call
+        (null, width$0, _aU_);
      /*<<camlinternalFormat.ml:1334:4>>*/ switch(padty$0){
       case 0:
-        /*<<camlinternalFormat.ml:1335:15>>*/ caml_call5
-        (Stdlib_String[6], str, 0, res, 0, len);
+        /*<<camlinternalFormat.ml:1335:15>>*/ Stdlib_String[6].call
+        (null, str, 0, res, 0, len);
        break;
       case 1:
-        /*<<camlinternalFormat.ml:1336:15>>*/ caml_call5
-        (Stdlib_String[6], str, 0, res, width$0 - len | 0, len);
+        /*<<camlinternalFormat.ml:1336:15>>*/ Stdlib_String[6].call
+        (null, str, 0, res, width$0 - len | 0, len);
        break;
       default:
        a:
@@ -16831,13 +16670,8 @@
          (res,
           0,
            /*<<camlinternalFormat.ml:1338:22>>*/ caml_string_get(str, 0));
-         /*<<camlinternalFormat.ml:1339:6>>*/ caml_call5
-         (Stdlib_String[6],
-          str,
-          1,
-          res,
-          (width$0 - len | 0) + 1 | 0,
-          len - 1 | 0);
+         /*<<camlinternalFormat.ml:1339:6>>*/ Stdlib_String[6].call
+         (null, str, 1, res, (width$0 - len | 0) + 1 | 0, len - 1 | 0);
         break;
        }
        a:
@@ -16856,25 +16690,20 @@
          (res,
           1,
            /*<<camlinternalFormat.ml:1341:22>>*/ caml_string_get(str, 1));
-         /*<<camlinternalFormat.ml:1342:6>>*/ caml_call5
-         (Stdlib_String[6],
-          str,
-          2,
-          res,
-          (width$0 - len | 0) + 2 | 0,
-          len - 2 | 0);
+         /*<<camlinternalFormat.ml:1342:6>>*/ Stdlib_String[6].call
+         (null, str, 2, res, (width$0 - len | 0) + 2 | 0, len - 2 | 0);
         break;
        }
-        /*<<camlinternalFormat.ml:1344:6>>*/ caml_call5
-        (Stdlib_String[6], str, 0, res, width$0 - len | 0, len);
+        /*<<camlinternalFormat.ml:1344:6>>*/ Stdlib_String[6].call
+        (null, str, 0, res, width$0 - len | 0, len);
     }
-     /*<<camlinternalFormat.ml:1346:4>>*/ return caml_call1
-            (Stdlib_Bytes[44], res) /*<<camlinternalFormat.ml:1346:30>>*/ ;
+     /*<<camlinternalFormat.ml:1346:4>>*/ return Stdlib_Bytes[44].call
+            (null, res) /*<<camlinternalFormat.ml:1346:30>>*/ ;
    }
    function fix_int_precision(prec, str){
     var
      prec$0 =
-        /*<<camlinternalFormat.ml:1350:13>>*/ caml_call1(Stdlib[18], prec),
+        /*<<camlinternalFormat.ml:1350:13>>*/ Stdlib[18].call(null, prec),
      len =  /*<<camlinternalFormat.ml:1351:2>>*/ caml_ml_string_length(str),
      c =  /*<<camlinternalFormat.ml:1352:8>>*/ caml_string_get(str, 0);
     a:
@@ -16898,21 +16727,16 @@
             break b;
            var
             res$1 =
-               /*<<camlinternalFormat.ml:1359:14>>*/ caml_call2
-               (Stdlib_Bytes[1], prec$0 + 2 | 0, 48);
+               /*<<camlinternalFormat.ml:1359:14>>*/ Stdlib_Bytes[1].call
+               (null, prec$0 + 2 | 0, 48);
             /*<<camlinternalFormat.ml:1360:20>>*/  /*<<camlinternalFormat.ml:1360:4>>*/ caml_bytes_set
             (res$1,
              1,
               /*<<camlinternalFormat.ml:1360:20>>*/ caml_string_get(str, 1));
-            /*<<camlinternalFormat.ml:1361:4>>*/ caml_call5
-            (Stdlib_String[6],
-             str,
-             2,
-             res$1,
-             (prec$0 - len | 0) + 4 | 0,
-             len - 2 | 0);
-            /*<<camlinternalFormat.ml:1361:52>>*/ return caml_call1
-                   (Stdlib_Bytes[44], res$1) /*<<camlinternalFormat.ml:1368:7>>*/ ;
+            /*<<camlinternalFormat.ml:1361:4>>*/ Stdlib_String[6].call
+            (null, str, 2, res$1, (prec$0 - len | 0) + 4 | 0, len - 2 | 0);
+            /*<<camlinternalFormat.ml:1361:52>>*/ return Stdlib_Bytes[44].call
+                   (null, res$1) /*<<camlinternalFormat.ml:1368:7>>*/ ;
           case 0:
           case 2: break;
           case 1:
@@ -16926,18 +16750,13 @@
         break a;
        var
         res$0 =
-           /*<<camlinternalFormat.ml:1354:14>>*/ caml_call2
-           (Stdlib_Bytes[1], prec$0 + 1 | 0, 48);
+           /*<<camlinternalFormat.ml:1354:14>>*/ Stdlib_Bytes[1].call
+           (null, prec$0 + 1 | 0, 48);
         /*<<camlinternalFormat.ml:1355:4>>*/ caml_bytes_set(res$0, 0, c);
-        /*<<camlinternalFormat.ml:1356:4>>*/ caml_call5
-        (Stdlib_String[6],
-         str,
-         1,
-         res$0,
-         (prec$0 - len | 0) + 2 | 0,
-         len - 1 | 0);
-        /*<<camlinternalFormat.ml:1356:52>>*/ return caml_call1
-               (Stdlib_Bytes[44], res$0) /*<<camlinternalFormat.ml:1368:7>>*/ ;
+        /*<<camlinternalFormat.ml:1356:4>>*/ Stdlib_String[6].call
+        (null, str, 1, res$0, (prec$0 - len | 0) + 2 | 0, len - 1 | 0);
+        /*<<camlinternalFormat.ml:1356:52>>*/ return Stdlib_Bytes[44].call
+               (null, res$0) /*<<camlinternalFormat.ml:1368:7>>*/ ;
       }
        /*<<camlinternalFormat.ml:1352:15>>*/ if(71 <= c){
        if(5 < c - 97 >>> 0) break a;
@@ -16947,12 +16766,12 @@
       /*<<camlinternalFormat.ml:1363:46>>*/ if(len < prec$0){
       var
        res =
-          /*<<camlinternalFormat.ml:1364:14>>*/ caml_call2
-          (Stdlib_Bytes[1], prec$0, 48);
-       /*<<camlinternalFormat.ml:1365:4>>*/ caml_call5
-       (Stdlib_String[6], str, 0, res, prec$0 - len | 0, len);
-       /*<<camlinternalFormat.ml:1365:42>>*/ return caml_call1
-              (Stdlib_Bytes[44], res) /*<<camlinternalFormat.ml:1368:7>>*/ ;
+          /*<<camlinternalFormat.ml:1364:14>>*/ Stdlib_Bytes[1].call
+          (null, prec$0, 48);
+       /*<<camlinternalFormat.ml:1365:4>>*/ Stdlib_String[6].call
+       (null, str, 0, res, prec$0 - len | 0, len);
+       /*<<camlinternalFormat.ml:1365:42>>*/ return Stdlib_Bytes[44].call
+              (null, res) /*<<camlinternalFormat.ml:1368:7>>*/ ;
      }
     }
      /*<<camlinternalFormat.ml:1368:4>>*/ return str;
@@ -16960,21 +16779,21 @@
    function string_to_caml_string(str){
     var
      str$0 =
-        /*<<camlinternalFormat.ml:1372:12>>*/ caml_call1
-        (Stdlib_String[25], str),
+        /*<<camlinternalFormat.ml:1372:12>>*/ Stdlib_String[25].call
+        (null, str),
      l =  /*<<camlinternalFormat.ml:1373:2>>*/ caml_ml_string_length(str$0),
      res =
-        /*<<camlinternalFormat.ml:1374:12>>*/ caml_call2
-        (Stdlib_Bytes[1], l + 2 | 0, 34);
+        /*<<camlinternalFormat.ml:1374:12>>*/ Stdlib_Bytes[1].call
+        (null, l + 2 | 0, 34);
      /*<<camlinternalFormat.ml:1375:2>>*/ caml_blit_string
      (str$0, 0, res, 1, l);
-     /*<<camlinternalFormat.ml:1375:34>>*/ return caml_call1
-            (Stdlib_Bytes[44], res) /*<<camlinternalFormat.ml:1376:28>>*/ ;
+     /*<<camlinternalFormat.ml:1375:34>>*/ return Stdlib_Bytes[44].call
+            (null, res) /*<<camlinternalFormat.ml:1376:28>>*/ ;
    }
    function format_of_fconv(fconv, prec){
     var
      prec$0 =
-        /*<<camlinternalFormat.ml:1414:15>>*/ caml_call1(Stdlib[18], prec),
+        /*<<camlinternalFormat.ml:1414:15>>*/ Stdlib[18].call(null, prec),
      symb =  /*<<camlinternalFormat.ml:1415:15>>*/ char_of_fconv(_r_, fconv),
      buf =  /*<<camlinternalFormat.ml:1416:14>>*/ buffer_create(16);
      /*<<camlinternalFormat.ml:1417:4>>*/ buffer_add_char(buf, 37);
@@ -16982,8 +16801,7 @@
      /*<<camlinternalFormat.ml:1419:4>>*/ buffer_add_char(buf, 46);
      /*<<camlinternalFormat.ml:1420:26>>*/  /*<<camlinternalFormat.ml:1420:4>>*/ buffer_add_string
      (buf,
-       /*<<camlinternalFormat.ml:1420:26>>*/ caml_call1
-       (Stdlib_Int[12], prec$0));
+       /*<<camlinternalFormat.ml:1420:26>>*/ Stdlib_Int[12].call(null, prec$0));
      /*<<camlinternalFormat.ml:1421:4>>*/ buffer_add_char(buf, symb);
      /*<<camlinternalFormat.ml:1421:28>>*/ return buffer_contents(buf) /*<<camlinternalFormat.ml:1422:23>>*/ ;
    }
@@ -17045,8 +16863,8 @@
       i = _aT_;
      }
     }
-     /*<<camlinternalFormat.ml:1446:4>>*/ return caml_call1
-            (Stdlib_Bytes[44], buf) /*<<camlinternalFormat.ml:1447:10>>*/ ;
+     /*<<camlinternalFormat.ml:1446:4>>*/ return Stdlib_Bytes[44].call
+            (null, buf) /*<<camlinternalFormat.ml:1447:10>>*/ ;
    }
    function convert_int(iconv, n){
      /*<<camlinternalFormat.ml:1380:22>>*/ switch(iconv){
@@ -17243,16 +17061,17 @@
          _aO_ =
             /*<<camlinternalFormat.ml:1476:17>>*/ _aN_
             ? str
-            :  /*<<camlinternalFormat.ml:1476:32>>*/ caml_call2
-              (Stdlib[28], str, cst$17);
+            :  /*<<camlinternalFormat.ml:1476:32>>*/ Stdlib
+               [28].call
+              (null, str, cst$17);
          /*<<camlinternalFormat.ml:1487:44>>*/ return caml_special_val(_aO_) /*<<camlinternalFormat.ml:1489:47>>*/ ;
        }
       case 6:
         /*<<camlinternalFormat.ml:1482:15>>*/ return hex(0) /*<<camlinternalFormat.ml:1489:47>>*/ ;
       case 7:
        var _aP_ =  /*<<camlinternalFormat.ml:1483:38>>*/ hex(0);
-        /*<<camlinternalFormat.ml:1483:46>>*/ return caml_call1
-               (Stdlib_String[26], _aP_) /*<<camlinternalFormat.ml:1489:47>>*/ ;
+        /*<<camlinternalFormat.ml:1483:46>>*/ return Stdlib_String[26].call
+               (null, _aP_) /*<<camlinternalFormat.ml:1489:47>>*/ ;
       case 8:
         /*<<camlinternalFormat.ml:1484:33>>*/ return  /*<<camlinternalFormat.ml:1484:41>>*/ caml_special_val
                ( /*<<camlinternalFormat.ml:1484:33>>*/ hex(0)) /*<<camlinternalFormat.ml:1489:47>>*/ ;
@@ -17288,19 +17107,19 @@
          /*<<camlinternalFormat.ml:1524:4>>*/ return function(c){
          var
           str =
-             /*<<camlinternalFormat.ml:1493:12>>*/ caml_call1
-             (Stdlib_Char[2], c),
+             /*<<camlinternalFormat.ml:1493:12>>*/ Stdlib_Char[2].call
+             (null, c),
           l =  /*<<camlinternalFormat.ml:1494:2>>*/ caml_ml_string_length(str),
           res =
-             /*<<camlinternalFormat.ml:1495:12>>*/ caml_call2
-             (Stdlib_Bytes[1], l + 2 | 0, 39);
+             /*<<camlinternalFormat.ml:1495:12>>*/ Stdlib_Bytes[1].call
+             (null, l + 2 | 0, 39);
           /*<<camlinternalFormat.ml:1496:2>>*/ caml_blit_string
           (str, 0, res, 1, l);
          var
           new_acc =
              /*<<camlinternalFormat.ml:1496:34>>*/ [4,
              acc,
-             caml_call1(Stdlib_Bytes[44], res)];
+             Stdlib_Bytes[44].call(null, res)];
           /*<<camlinternalFormat.ml:1526:6>>*/ return make_printf
                  (k, new_acc, rest$0) /*<<camlinternalFormat.ml:1526:32>>*/ ;} /*<<camlinternalFormat.ml:1524:4>>*/ ;
        case 2:
@@ -17524,8 +17343,9 @@
           /*<<camlinternalFormat.ml:1574:6>>*/ return  /*<<camlinternalFormat.ml:1574:42>>*/ make_printf
                  (k,
                   acc,
-                   /*<<camlinternalFormat.ml:1574:6>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _aM_, rest$13)) /*<<camlinternalFormat.ml:1574:42>>*/ ;} /*<<camlinternalFormat.ml:1573:4>>*/ ;
+                   /*<<camlinternalFormat.ml:1574:6>>*/ CamlinternalFormatBasics
+                    [3].call
+                   (null, _aM_, rest$13)) /*<<camlinternalFormat.ml:1574:42>>*/ ;} /*<<camlinternalFormat.ml:1573:4>>*/ ;
        case 15:
         var rest$14 =  /*<<camlinternalFormat.ml:1518:17>>*/ fmt[1];
          /*<<camlinternalFormat.ml:1544:4>>*/ return function(f, x){
@@ -17806,8 +17626,9 @@
           /*<<camlinternalFormat.ml:1655:35>>*/ return  /*<<camlinternalFormat.ml:1655:57>>*/ make_from_fmtty
                  (k,
                   acc,
-                   /*<<camlinternalFormat.ml:1655:35>>*/ caml_call2
-                   (CamlinternalFormatBasics[1], ty, rest$8),
+                   /*<<camlinternalFormat.ml:1655:35>>*/ CamlinternalFormatBasics
+                    [1].call
+                   (null, ty, rest$8),
                   fmt) /*<<camlinternalFormat.ml:1655:61>>*/ ;} /*<<camlinternalFormat.ml:1655:4>>*/ ;
        case 10:
         var rest$9 =  /*<<camlinternalFormat.ml:1637:23>>*/ fmtty[1];
@@ -18196,8 +18017,9 @@
           /*<<camlinternalFormat.ml:1842:12>>*/ return  /*<<camlinternalFormat.ml:1842:48>>*/ make_iprintf
                  (k,
                   o,
-                   /*<<camlinternalFormat.ml:1842:12>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], _aL_, rest$19)) /*<<camlinternalFormat.ml:1842:48>>*/ ;} /*<<camlinternalFormat.ml:1840:8>>*/ ;
+                   /*<<camlinternalFormat.ml:1842:12>>*/ CamlinternalFormatBasics
+                    [3].call
+                   (null, _aL_, rest$19)) /*<<camlinternalFormat.ml:1842:48>>*/ ;} /*<<camlinternalFormat.ml:1840:8>>*/ ;
        case 15:
         var
          rest$20 =  /*<<camlinternalFormat.ml:1788:17>>*/ fmt[1],
@@ -18408,8 +18230,8 @@
             /*<<camlinternalFormat.ml:1899:12>>*/ string_of_formatting_lit
             (fmting_lit);
          /*<<camlinternalFormat.ml:1900:4>>*/ output_acc(o, p);
-         /*<<camlinternalFormat.ml:1900:18>>*/ return caml_call2
-                (Stdlib[66], o, s) /*<<camlinternalFormat.ml:1912:34>>*/ ;
+         /*<<camlinternalFormat.ml:1900:18>>*/ return Stdlib[66].call
+                (null, o, s) /*<<camlinternalFormat.ml:1912:34>>*/ ;
        case 1:
         var
          match =  /*<<camlinternalFormat.ml:1897:27>>*/ acc[2],
@@ -18417,15 +18239,15 @@
         if(0 === match[0]){
          var acc$0 = match[1];
           /*<<camlinternalFormat.ml:1902:4>>*/ output_acc(o, p$0);
-          /*<<camlinternalFormat.ml:1902:20>>*/ caml_call2
-          (Stdlib[66], o, cst$18);
+          /*<<camlinternalFormat.ml:1902:20>>*/ Stdlib[66].call
+          (null, o, cst$18);
           /*<<camlinternalFormat.ml:1902:40>>*/ acc = acc$0;
         }
         else{
          var acc$1 =  /*<<camlinternalFormat.ml:1897:27>>*/ match[1];
           /*<<camlinternalFormat.ml:1904:4>>*/ output_acc(o, p$0);
-          /*<<camlinternalFormat.ml:1904:20>>*/ caml_call2
-          (Stdlib[66], o, cst$19);
+          /*<<camlinternalFormat.ml:1904:20>>*/ Stdlib[66].call
+          (null, o, cst$19);
           /*<<camlinternalFormat.ml:1904:40>>*/ acc = acc$1;
         }
         break;
@@ -18436,24 +18258,23 @@
        case 7:
         var p$4 =  /*<<camlinternalFormat.ml:1897:27>>*/ acc[1];
          /*<<camlinternalFormat.ml:1910:32>>*/ output_acc(o, p$4);
-         /*<<camlinternalFormat.ml:1910:46>>*/ return caml_call1
-                (Stdlib[63], o) /*<<camlinternalFormat.ml:1912:34>>*/ ;
+         /*<<camlinternalFormat.ml:1910:46>>*/ return Stdlib[63].call(null, o) /*<<camlinternalFormat.ml:1912:34>>*/ ;
        case 8:
         var msg =  /*<<camlinternalFormat.ml:1897:27>>*/ acc[2], p$5 = acc[1];
          /*<<camlinternalFormat.ml:1911:32>>*/ output_acc(o, p$5);
-         /*<<camlinternalFormat.ml:1911:46>>*/ return caml_call1
-                (Stdlib[1], msg) /*<<camlinternalFormat.ml:1912:34>>*/ ;
+         /*<<camlinternalFormat.ml:1911:46>>*/ return Stdlib[1].call
+                (null, msg) /*<<camlinternalFormat.ml:1912:34>>*/ ;
        case 2:
        case 4:
         var s$0 =  /*<<camlinternalFormat.ml:1897:27>>*/ acc[2], p$1 = acc[1];
          /*<<camlinternalFormat.ml:1906:32>>*/ output_acc(o, p$1);
-         /*<<camlinternalFormat.ml:1906:46>>*/ return caml_call2
-                (Stdlib[66], o, s$0) /*<<camlinternalFormat.ml:1912:34>>*/ ;
+         /*<<camlinternalFormat.ml:1906:46>>*/ return Stdlib[66].call
+                (null, o, s$0) /*<<camlinternalFormat.ml:1912:34>>*/ ;
        default:
         var c =  /*<<camlinternalFormat.ml:1897:27>>*/ acc[2], p$2 = acc[1];
          /*<<camlinternalFormat.ml:1908:32>>*/ output_acc(o, p$2);
-         /*<<camlinternalFormat.ml:1908:46>>*/ return caml_call2
-                (Stdlib[65], o, c) /*<<camlinternalFormat.ml:1912:34>>*/ ;
+         /*<<camlinternalFormat.ml:1908:46>>*/ return Stdlib[65].call
+                (null, o, c) /*<<camlinternalFormat.ml:1912:34>>*/ ;
      }
     }
    }
@@ -18471,8 +18292,8 @@
             /*<<camlinternalFormat.ml:1919:12>>*/ string_of_formatting_lit
             (fmting_lit);
          /*<<camlinternalFormat.ml:1920:4>>*/ bufput_acc(b, p);
-         /*<<camlinternalFormat.ml:1920:18>>*/ return caml_call2
-                (Stdlib_Buffer[16], b, s) /*<<camlinternalFormat.ml:1932:34>>*/ ;
+         /*<<camlinternalFormat.ml:1920:18>>*/ return Stdlib_Buffer[16].call
+                (null, b, s) /*<<camlinternalFormat.ml:1932:34>>*/ ;
        case 1:
         var
          match =  /*<<camlinternalFormat.ml:1917:27>>*/ acc[2],
@@ -18480,15 +18301,15 @@
         if(0 === match[0]){
          var acc$0 = match[1];
           /*<<camlinternalFormat.ml:1922:4>>*/ bufput_acc(b, p$0);
-          /*<<camlinternalFormat.ml:1922:20>>*/ caml_call2
-          (Stdlib_Buffer[16], b, cst$20);
+          /*<<camlinternalFormat.ml:1922:20>>*/ Stdlib_Buffer[16].call
+          (null, b, cst$20);
           /*<<camlinternalFormat.ml:1922:44>>*/ acc = acc$0;
         }
         else{
          var acc$1 =  /*<<camlinternalFormat.ml:1917:27>>*/ match[1];
           /*<<camlinternalFormat.ml:1924:4>>*/ bufput_acc(b, p$0);
-          /*<<camlinternalFormat.ml:1924:20>>*/ caml_call2
-          (Stdlib_Buffer[16], b, cst$21);
+          /*<<camlinternalFormat.ml:1924:20>>*/ Stdlib_Buffer[16].call
+          (null, b, cst$21);
           /*<<camlinternalFormat.ml:1924:44>>*/ acc = acc$1;
         }
         break;
@@ -18503,19 +18324,19 @@
        case 8:
         var msg =  /*<<camlinternalFormat.ml:1917:27>>*/ acc[2], p$4 = acc[1];
          /*<<camlinternalFormat.ml:1931:32>>*/ bufput_acc(b, p$4);
-         /*<<camlinternalFormat.ml:1931:46>>*/ return caml_call1
-                (Stdlib[1], msg) /*<<camlinternalFormat.ml:1932:34>>*/ ;
+         /*<<camlinternalFormat.ml:1931:46>>*/ return Stdlib[1].call
+                (null, msg) /*<<camlinternalFormat.ml:1932:34>>*/ ;
        case 2:
        case 4:
         var s$0 =  /*<<camlinternalFormat.ml:1917:27>>*/ acc[2], p$1 = acc[1];
          /*<<camlinternalFormat.ml:1926:32>>*/ bufput_acc(b, p$1);
-         /*<<camlinternalFormat.ml:1926:46>>*/ return caml_call2
-                (Stdlib_Buffer[16], b, s$0) /*<<camlinternalFormat.ml:1932:34>>*/ ;
+         /*<<camlinternalFormat.ml:1926:46>>*/ return Stdlib_Buffer[16].call
+                (null, b, s$0) /*<<camlinternalFormat.ml:1932:34>>*/ ;
        default:
         var c =  /*<<camlinternalFormat.ml:1917:27>>*/ acc[2], p$2 = acc[1];
          /*<<camlinternalFormat.ml:1928:32>>*/ bufput_acc(b, p$2);
-         /*<<camlinternalFormat.ml:1928:46>>*/ return caml_call2
-                (Stdlib_Buffer[12], b, c) /*<<camlinternalFormat.ml:1932:34>>*/ ;
+         /*<<camlinternalFormat.ml:1928:46>>*/ return Stdlib_Buffer[12].call
+                (null, b, c) /*<<camlinternalFormat.ml:1932:34>>*/ ;
      }
     }
    }
@@ -18533,8 +18354,8 @@
             /*<<camlinternalFormat.ml:1940:12>>*/ string_of_formatting_lit
             (fmting_lit);
          /*<<camlinternalFormat.ml:1941:4>>*/ strput_acc(b, p);
-         /*<<camlinternalFormat.ml:1941:18>>*/ return caml_call2
-                (Stdlib_Buffer[16], b, s) /*<<camlinternalFormat.ml:1953:34>>*/ ;
+         /*<<camlinternalFormat.ml:1941:18>>*/ return Stdlib_Buffer[16].call
+                (null, b, s) /*<<camlinternalFormat.ml:1953:34>>*/ ;
        case 1:
         var
          match =  /*<<camlinternalFormat.ml:1938:27>>*/ acc[2],
@@ -18542,15 +18363,15 @@
         if(0 === match[0]){
          var acc$0 = match[1];
           /*<<camlinternalFormat.ml:1943:4>>*/ strput_acc(b, p$0);
-          /*<<camlinternalFormat.ml:1943:20>>*/ caml_call2
-          (Stdlib_Buffer[16], b, cst$22);
+          /*<<camlinternalFormat.ml:1943:20>>*/ Stdlib_Buffer[16].call
+          (null, b, cst$22);
           /*<<camlinternalFormat.ml:1943:44>>*/ acc = acc$0;
         }
         else{
          var acc$1 =  /*<<camlinternalFormat.ml:1938:27>>*/ match[1];
           /*<<camlinternalFormat.ml:1945:4>>*/ strput_acc(b, p$0);
-          /*<<camlinternalFormat.ml:1945:20>>*/ caml_call2
-          (Stdlib_Buffer[16], b, cst$23);
+          /*<<camlinternalFormat.ml:1945:20>>*/ Stdlib_Buffer[16].call
+          (null, b, cst$23);
           /*<<camlinternalFormat.ml:1945:44>>*/ acc = acc$1;
         }
         break;
@@ -18558,8 +18379,8 @@
         var f =  /*<<camlinternalFormat.ml:1938:27>>*/ acc[2], p$3 = acc[1];
          /*<<camlinternalFormat.ml:1950:32>>*/ strput_acc(b, p$3);
         var _aL_ =  /*<<camlinternalFormat.ml:1950:68>>*/ caml_call1(f, 0);
-         /*<<camlinternalFormat.ml:1950:74>>*/ return caml_call2
-                (Stdlib_Buffer[16], b, _aL_) /*<<camlinternalFormat.ml:1953:34>>*/ ;
+         /*<<camlinternalFormat.ml:1950:74>>*/ return Stdlib_Buffer[16].call
+                (null, b, _aL_) /*<<camlinternalFormat.ml:1953:34>>*/ ;
        case 7:
         var acc$2 =  /*<<camlinternalFormat.ml:1938:27>>*/ acc[1];
          /*<<camlinternalFormat.ml:1951:32>>*/ acc = acc$2;
@@ -18567,19 +18388,19 @@
        case 8:
         var msg =  /*<<camlinternalFormat.ml:1938:27>>*/ acc[2], p$4 = acc[1];
          /*<<camlinternalFormat.ml:1952:32>>*/ strput_acc(b, p$4);
-         /*<<camlinternalFormat.ml:1952:46>>*/ return caml_call1
-                (Stdlib[1], msg) /*<<camlinternalFormat.ml:1953:34>>*/ ;
+         /*<<camlinternalFormat.ml:1952:46>>*/ return Stdlib[1].call
+                (null, msg) /*<<camlinternalFormat.ml:1953:34>>*/ ;
        case 2:
        case 4:
         var s$0 =  /*<<camlinternalFormat.ml:1938:27>>*/ acc[2], p$1 = acc[1];
          /*<<camlinternalFormat.ml:1947:32>>*/ strput_acc(b, p$1);
-         /*<<camlinternalFormat.ml:1947:46>>*/ return caml_call2
-                (Stdlib_Buffer[16], b, s$0) /*<<camlinternalFormat.ml:1953:34>>*/ ;
+         /*<<camlinternalFormat.ml:1947:46>>*/ return Stdlib_Buffer[16].call
+                (null, b, s$0) /*<<camlinternalFormat.ml:1953:34>>*/ ;
        default:
         var c =  /*<<camlinternalFormat.ml:1938:27>>*/ acc[2], p$2 = acc[1];
          /*<<camlinternalFormat.ml:1949:32>>*/ strput_acc(b, p$2);
-         /*<<camlinternalFormat.ml:1949:46>>*/ return caml_call2
-                (Stdlib_Buffer[12], b, c) /*<<camlinternalFormat.ml:1953:34>>*/ ;
+         /*<<camlinternalFormat.ml:1949:46>>*/ return Stdlib_Buffer[12].call
+                (null, b, c) /*<<camlinternalFormat.ml:1953:34>>*/ ;
      }
     }
    }
@@ -18587,15 +18408,14 @@
     var
      fmt =  /*<<camlinternalFormat.ml:1959:21>>*/ param[1],
      buf =
-        /*<<camlinternalFormat.ml:1960:12>>*/ caml_call1
-        (Stdlib_Buffer[1], 256);
+        /*<<camlinternalFormat.ml:1960:12>>*/ Stdlib_Buffer[1].call(null, 256);
     function k(acc){
       /*<<camlinternalFormat.ml:1961:14>>*/ strput_acc(buf, acc);
      var
       _aL_ =
-         /*<<camlinternalFormat.ml:1961:43>>*/ caml_call1
-         (Stdlib_Buffer[2], buf);
-      /*<<camlinternalFormat.ml:1961:64>>*/ return caml_call1(Stdlib[2], _aL_);
+         /*<<camlinternalFormat.ml:1961:43>>*/ Stdlib_Buffer[2].call
+         (null, buf);
+      /*<<camlinternalFormat.ml:1961:64>>*/ return Stdlib[2].call(null, _aL_);
     }
      /*<<camlinternalFormat.ml:1962:2>>*/ return make_printf(k, 0, fmt) /*<<camlinternalFormat.ml:1962:30>>*/ ;
    }
@@ -18633,8 +18453,8 @@
     }
     var
      box_name =
-        /*<<camlinternalFormat.ml:1989:19>>*/ caml_call3
-        (Stdlib_String[16], str, wstart, wend - wstart | 0),
+        /*<<camlinternalFormat.ml:1989:19>>*/ Stdlib_String[16].call
+        (null, str, wstart, wend - wstart | 0),
      nstart =  /*<<camlinternalFormat.ml:1990:17>>*/ parse_spaces(wend),
      nend =  /*<<camlinternalFormat.ml:1991:15>>*/ nstart;
     for(;;){
@@ -18656,8 +18476,8 @@
       var
        _aL_ =
           /*<<camlinternalFormat.ml:1994:26>>*/  /*<<camlinternalFormat.ml:1994:12>>*/ runtime.caml_int_of_string
-          ( /*<<camlinternalFormat.ml:1994:26>>*/ caml_call3
-            (Stdlib_String[16], str, nstart, nend - nstart | 0)),
+          ( /*<<camlinternalFormat.ml:1994:26>>*/ Stdlib_String[16].call
+            (null, str, nstart, nend - nstart | 0)),
        indent = _aL_;
      }
      catch(exn$0){
@@ -20055,8 +19875,8 @@
              if(17 === switcher$0){
               var
                s =
-                  /*<<camlinternalFormat.ml:2674:24>>*/ caml_call3
-                  (Stdlib_String[16],
+                  /*<<camlinternalFormat.ml:2674:24>>*/ Stdlib_String[16].call
+                  (null,
                    str,
                    str_ind$0 - 2 | 0,
                    (str_ind_3 - str_ind$0 | 0) + 3 | 0),
@@ -20083,8 +19903,8 @@
                      (Stdlib[8], 1);
              var
               s$0 =
-                 /*<<camlinternalFormat.ml:2680:24>>*/ caml_call3
-                 (Stdlib_String[16],
+                 /*<<camlinternalFormat.ml:2680:24>>*/ Stdlib_String[16].call
+                 (null,
                   str,
                   str_ind$0 - 2 | 0,
                   (str_ind_5 - str_ind$0 | 0) + 3 | 0),
@@ -20151,8 +19971,8 @@
                      (Stdlib[8], 1);
              var
               s$1 =
-                 /*<<camlinternalFormat.ml:2702:18>>*/ caml_call3
-                 (Stdlib_String[16],
+                 /*<<camlinternalFormat.ml:2702:18>>*/ Stdlib_String[16].call
+                 (null,
                   str,
                   str_ind$1 - 2 | 0,
                   (str_ind_3$0 - str_ind$1 | 0) + 3 | 0),
@@ -20224,15 +20044,15 @@
               (Stdlib[8], 1);
       var
        ind =
-          /*<<camlinternalFormat.ml:2643:18>>*/ caml_call3
-          (Stdlib_String[32], str, str_ind + 1 | 0, 62);
+          /*<<camlinternalFormat.ml:2643:18>>*/ Stdlib_String[32].call
+          (null, str, str_ind + 1 | 0, 62);
        /*<<camlinternalFormat.ml:2644:8>>*/ if(end_ind <= ind)
         /*<<camlinternalFormat.ml:2644:31>>*/ throw caml_maybe_attach_backtrace
               (Stdlib[8], 1);
       var
        sub_str =
-          /*<<camlinternalFormat.ml:2645:22>>*/ caml_call3
-          (Stdlib_String[16], str, str_ind, (ind - str_ind | 0) + 1 | 0),
+          /*<<camlinternalFormat.ml:2645:22>>*/ Stdlib_String[16].call
+          (null, str, str_ind, (ind - str_ind | 0) + 1 | 0),
        fmt_rest$0 =
           /*<<camlinternalFormat.ml:2646:31>>*/ parse(ind + 1 | 0, end_ind)[1],
        sub_fmt =
@@ -20273,7 +20093,7 @@
        for(;;){
          /*<<camlinternalFormat.ml:2725:33>>*/  /*<<camlinternalFormat.ml:2725:8>>*/ add_in_char_set
          (char_set,
-           /*<<camlinternalFormat.ml:2725:33>>*/ caml_call1(Stdlib[29], i));
+           /*<<camlinternalFormat.ml:2725:33>>*/ Stdlib[29].call(null, i));
         var _ac_ =  /*<<camlinternalFormat.ml:2725:48>>*/ i + 1 | 0;
         if(c === i) break;
         i = _ac_;
@@ -20513,8 +20333,8 @@
                   fmt]]
                : [0,
                  [11,
-                   /*<<camlinternalFormat.ml:2846:39>>*/ caml_call3
-                   (Stdlib_String[16], str, lit_start, size),
+                   /*<<camlinternalFormat.ml:2846:39>>*/ Stdlib_String[16].call
+                   (null, str, lit_start, size),
                   fmt]] /*<<camlinternalFormat.ml:2846:75>>*/ ;
     }
     function search_subformat_end(str_ind$7, end_ind, c){
@@ -20725,8 +20545,8 @@
     function incompatible_flag(pct_ind, str_ind, symb, option){
      var
       subfmt =
-         /*<<camlinternalFormat.ml:2963:19>>*/ caml_call3
-         (Stdlib_String[16], str, pct_ind, str_ind - pct_ind | 0);
+         /*<<camlinternalFormat.ml:2963:19>>*/ Stdlib_String[16].call
+         (null, str, pct_ind, str_ind - pct_ind | 0);
       /*<<camlinternalFormat.ml:2964:6>>*/ return caml_call5
              (failwith_message(_Y_), str, pct_ind, option, symb, subfmt) /*<<camlinternalFormat.ml:2967:38>>*/ ;
     }
@@ -20818,16 +20638,6 @@
             ? 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,
@@ -20835,11 +20645,11 @@
     Stdlib = global_data.Stdlib;
    function kfprintf(k, o, param){
     var fmt =  /*<<printf.ml:19:13>>*/ param[1];
-     /*<<printf.ml:20:2>>*/ return caml_call3
-            (CamlinternalFormat[7],
+     /*<<printf.ml:20:2>>*/ return CamlinternalFormat[7].call
+            (null,
              function(acc){
-               /*<<printf.ml:20:26>>*/ caml_call2
-               (CamlinternalFormat[9], o, acc);
+               /*<<printf.ml:20:26>>*/ CamlinternalFormat[9].call
+               (null, o, acc);
                /*<<printf.ml:20:42>>*/ return caml_call1(k, o) /*<<printf.ml:20:47>>*/ ;
              },
              0,
@@ -20847,11 +20657,11 @@
    }
    function kbprintf(k, b, param){
     var fmt =  /*<<printf.ml:21:13>>*/ param[1];
-     /*<<printf.ml:22:2>>*/ return caml_call3
-            (CamlinternalFormat[7],
+     /*<<printf.ml:22:2>>*/ return CamlinternalFormat[7].call
+            (null,
              function(acc){
-               /*<<printf.ml:22:26>>*/ caml_call2
-               (CamlinternalFormat[10], b, acc);
+               /*<<printf.ml:22:26>>*/ CamlinternalFormat[10].call
+               (null, b, acc);
                /*<<printf.ml:22:42>>*/ return caml_call1(k, b) /*<<printf.ml:22:47>>*/ ;
              },
              0,
@@ -20859,8 +20669,8 @@
    }
    function ikfprintf(k, oc, param){
     var fmt =  /*<<printf.ml:23:14>>*/ param[1];
-     /*<<printf.ml:24:2>>*/ return caml_call3
-            (CamlinternalFormat[8], k, oc, fmt) /*<<printf.ml:24:23>>*/ ;
+     /*<<printf.ml:24:2>>*/ return CamlinternalFormat[8].call
+            (null, k, oc, fmt) /*<<printf.ml:24:23>>*/ ;
    }
    function fprintf(oc, fmt){
      /*<<printf.ml:27:21>>*/ return kfprintf
@@ -20887,13 +20697,13 @@
    function ksprintf(k, param){
     var fmt =  /*<<printf.ml:34:13>>*/ param[1];
     function k$0(acc){
-     var buf =  /*<<printf.ml:36:14>>*/ caml_call1(Stdlib_Buffer[1], 64);
-      /*<<printf.ml:37:4>>*/ caml_call2(CamlinternalFormat[11], buf, acc);
+     var buf =  /*<<printf.ml:36:14>>*/ Stdlib_Buffer[1].call(null, 64);
+      /*<<printf.ml:37:4>>*/ CamlinternalFormat[11].call(null, buf, acc);
       /*<<printf.ml:38:6>>*/ return  /*<<printf.ml:38:27>>*/ caml_call1
-             (k,  /*<<printf.ml:38:6>>*/ caml_call1(Stdlib_Buffer[2], buf)) /*<<printf.ml:38:27>>*/ ;
+             (k,  /*<<printf.ml:38:6>>*/ Stdlib_Buffer[2].call(null, buf)) /*<<printf.ml:38:27>>*/ ;
     }
-     /*<<printf.ml:39:2>>*/ return caml_call3
-            (CamlinternalFormat[7], k$0, 0, fmt) /*<<printf.ml:39:31>>*/ ;
+     /*<<printf.ml:39:2>>*/ return CamlinternalFormat[7].call
+            (null, k$0, 0, fmt) /*<<printf.ml:39:31>>*/ ;
    }
    function sprintf(fmt){
      /*<<printf.ml:41:18>>*/ return ksprintf
@@ -20968,16 +20778,6 @@
             ? 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]);
-   }
    var
     global_data = runtime.caml_get_global_data(),
     cst$7 = "\n",
@@ -21032,17 +20832,17 @@
     var
      t =  /*<<arg.ml:77:2>>*/ l[2],
      h = l[1],
-     _N_ =  /*<<arg.ml:79:53>>*/ caml_call2(Stdlib[28], prefix, h),
+     _N_ =  /*<<arg.ml:79:53>>*/ Stdlib[28].call(null, prefix, h),
      _O_ =
-        /*<<arg.ml:79:12>>*/ caml_call3
-        (Stdlib_List[26],
+        /*<<arg.ml:79:12>>*/ Stdlib_List[26].call
+        (null,
          function(x, y){
-          var _O_ =  /*<<arg.ml:79:44>>*/ caml_call2(Stdlib[28], sep, y);
-           /*<<arg.ml:79:51>>*/ return caml_call2(Stdlib[28], x, _O_);
+          var _O_ =  /*<<arg.ml:79:44>>*/ Stdlib[28].call(null, sep, y);
+           /*<<arg.ml:79:51>>*/ return Stdlib[28].call(null, x, _O_);
          },
          _N_,
          t);
-     /*<<arg.ml:79:68>>*/ return caml_call2(Stdlib[28], _O_, suffix) /*<<arg.ml:79:77>>*/ ;
+     /*<<arg.ml:79:68>>*/ return Stdlib[28].call(null, _O_, suffix) /*<<arg.ml:79:77>>*/ ;
    }
    function help_action(param){
      /*<<arg.ml:91:21>>*/ throw caml_maybe_attach_backtrace([0, Stop, _c_], 1);
@@ -21074,14 +20874,15 @@
          [0, cst_help$0, [0, help_action], cst_Display_this_list_of_optio$0],
          0];
     }
-    var _L_ =  /*<<arg.ml:103:13>>*/ caml_call2(Stdlib[37], add1, add2);
-     /*<<arg.ml:103:26>>*/ return caml_call2(Stdlib[37], speclist, _L_);
+    var _L_ =  /*<<arg.ml:103:13>>*/ Stdlib[37].call(null, add1, add2);
+     /*<<arg.ml:103:26>>*/ return Stdlib[37].call(null, speclist, _L_);
    }
    function usage_b(buf, speclist, errmsg){
-     /*<<arg.ml:107:2>>*/ caml_call3(Stdlib_Printf[5], buf, _d_, errmsg);
+     /*<<arg.ml:107:2>>*/ caml_call1
+     (Stdlib_Printf[5].call(null, buf, _d_), errmsg);
     var _K_ =  /*<<arg.ml:108:29>>*/ add_help(speclist);
-     /*<<arg.ml:108:28>>*/ return caml_call2
-            (Stdlib_List[18],
+     /*<<arg.ml:108:28>>*/ return Stdlib_List[18].call
+            (null,
              function(param){
               var
                doc =  /*<<arg.ml:82:15>>*/ param[3],
@@ -21091,24 +20892,25 @@
                   /*<<arg.ml:83:2>>*/ 0 < caml_ml_string_length(doc) ? 1 : 0;
               if(! _K_) return _K_;
                /*<<arg.ml:84:4>>*/ if(11 !== spec[0])
-                /*<<arg.ml:88:8>>*/ return caml_call4
-                       (Stdlib_Printf[5], buf, _a_, key, doc);
+                /*<<arg.ml:88:8>>*/ return caml_call2
+                       (Stdlib_Printf[5].call(null, buf, _a_), key, doc);
               var
                l =  /*<<arg.ml:84:4>>*/ spec[1],
                _L_ =  /*<<arg.ml:86:38>>*/ make_symlist(cst$1, cst$0, cst, l);
-               /*<<arg.ml:86:66>>*/ return caml_call5
-                      (Stdlib_Printf[5], buf, _b_, key, _L_, doc);
+               /*<<arg.ml:86:66>>*/ return caml_call3
+                      (Stdlib_Printf[5].call(null, buf, _b_), key, _L_, doc);
              },
              _K_) /*<<arg.ml:108:48>>*/ ;
    }
    function usage_string(speclist, errmsg){
-    var b =  /*<<arg.ml:112:10>>*/ caml_call1(Stdlib_Buffer[1], 200);
+    var b =  /*<<arg.ml:112:10>>*/ Stdlib_Buffer[1].call(null, 200);
      /*<<arg.ml:113:2>>*/ usage_b(b, speclist, errmsg);
-     /*<<arg.ml:113:27>>*/ return caml_call1(Stdlib_Buffer[2], b) /*<<arg.ml:114:19>>*/ ;
+     /*<<arg.ml:113:27>>*/ return Stdlib_Buffer[2].call(null, b) /*<<arg.ml:114:19>>*/ ;
    }
    function usage(speclist, errmsg){
     var _K_ =  /*<<arg.ml:118:15>>*/ usage_string(speclist, errmsg);
-     /*<<arg.ml:118:45>>*/ return caml_call2(Stdlib_Printf[3], _e_, _K_);
+     /*<<arg.ml:118:45>>*/ return caml_call1
+            (Stdlib_Printf[3].call(null, _e_), _K_);
    }
    var
     current =  /*<<?>>*/ [0, 0],
@@ -21178,7 +20980,7 @@
     var initpos =  /*<<arg.ml:137:2>>*/ current[1];
     function convert_error(error){
      var
-      b =  /*<<arg.ml:143:12>>*/ caml_call1(Stdlib_Buffer[1], 200),
+      b =  /*<<arg.ml:143:12>>*/ Stdlib_Buffer[1].call(null, 200),
       progname =
          /*<<arg.ml:144:4>>*/ initpos < argv[1].length - 1
          ?  /*<<arg.ml:145:45>>*/ caml_check_bound
@@ -21189,34 +20991,34 @@
        case 0:
         var s = error[1];
         if(s !== cst_help$4 && s !== cst_help$3)
-          /*<<arg.ml:150:10>>*/ caml_call4
-          (Stdlib_Printf[5], b, _f_, progname, s);
+          /*<<arg.ml:150:10>>*/ caml_call2
+          (Stdlib_Printf[5].call(null, b, _f_), progname, s);
         break;
        case 1:
         var
          expected =  /*<<arg.ml:146:4>>*/ error[3],
          arg = error[2],
          opt = error[1];
-         /*<<arg.ml:154:10>>*/ caml_call6
-         (Stdlib_Printf[5], b, _i_, progname, arg, opt, expected);
+         /*<<arg.ml:154:10>>*/ caml_call4
+         (Stdlib_Printf[5].call(null, b, _i_), progname, arg, opt, expected);
         break;
        case 2:
         var s$0 =  /*<<arg.ml:146:4>>*/ error[1];
-         /*<<arg.ml:152:10>>*/ caml_call4
-         (Stdlib_Printf[5], b, _j_, progname, s$0);
+         /*<<arg.ml:152:10>>*/ caml_call2
+         (Stdlib_Printf[5].call(null, b, _j_), progname, s$0);
         break;
        default:
         var s$1 =  /*<<arg.ml:146:4>>*/ error[1];
-         /*<<arg.ml:157:10>>*/ caml_call4
-         (Stdlib_Printf[5], b, _k_, progname, s$1);
+         /*<<arg.ml:157:10>>*/ caml_call2
+         (Stdlib_Printf[5].call(null, b, _k_), progname, s$1);
      }
       /*<<arg.ml:159:4>>*/ usage_b(b, speclist[1], errmsg);
       /*<<arg.ml:160:7>>*/ if
       (!
        caml_equal(error, _g_)
        && !  /*<<arg.ml:160:34>>*/ caml_equal(error, _h_))
-       /*<<arg.ml:162:13>>*/ return [0, Bad, caml_call1(Stdlib_Buffer[2], b)] /*<<arg.ml:162:32>>*/ ;
-      /*<<arg.ml:161:14>>*/ return [0, Help, caml_call1(Stdlib_Buffer[2], b)] /*<<arg.ml:161:33>>*/ ;
+       /*<<arg.ml:162:13>>*/ return [0, Bad, Stdlib_Buffer[2].call(null, b)] /*<<arg.ml:162:32>>*/ ;
+      /*<<arg.ml:161:14>>*/ return [0, Help, Stdlib_Buffer[2].call(null, b)] /*<<arg.ml:161:33>>*/ ;
      /*<<arg.ml:162:32>>*/ }
      /*<<arg.ml:164:2>>*/ current[1]++;
      /*<<arg.ml:165:2>>*/ for(;;){
@@ -21225,7 +21027,7 @@
       var
        _E_ = current[1],
        s =  /*<<arg.ml:167:14>>*/ caml_check_bound(argv[1], _E_)[_E_ + 1];
-       /*<<arg.ml:168:9>>*/ if(caml_call2(Stdlib_String[11], cst$3, s)){
+       /*<<arg.ml:168:9>>*/ if(Stdlib_String[11].call(null, cst$3, s)){
         /*<<arg.ml:168:41>>*/ try{
         var
          follow$1 =  /*<<arg.ml:170:32>>*/ 0,
@@ -21238,13 +21040,12 @@
         if(exn$0 !== Stdlib[8]) throw caml_maybe_attach_backtrace(exn$0, 0);
         try{
          var
-          i =  /*<<arg.ml:71:10>>*/ caml_call2(Stdlib_String[36], s, 61),
+          i =  /*<<arg.ml:71:10>>*/ Stdlib_String[36].call(null, s, 61),
           len =  /*<<arg.ml:72:2>>*/ caml_ml_string_length(s),
           arg =
-             /*<<arg.ml:73:20>>*/ caml_call3
-             (Stdlib_String[16], s, i + 1 | 0, len - (i + 1 | 0) | 0),
-          keyword =
-             /*<<arg.ml:73:2>>*/ caml_call3(Stdlib_String[16], s, 0, i),
+             /*<<arg.ml:73:20>>*/ Stdlib_String[16].call
+             (null, s, i + 1 | 0, len - (i + 1 | 0) | 0),
+          keyword =  /*<<arg.ml:73:2>>*/ Stdlib_String[16].call(null, s, 0, i),
           follow =  /*<<arg.ml:174:12>>*/ [0, arg],
           _F_ = assoc3(keyword, speclist[1]),
           follow$0 = follow,
@@ -21298,7 +21099,7 @@
                arg =  /*<<arg.ml:196:22>>*/ get_arg$0(0);
                /*<<arg.ml:197:24>>*/ try{
                var
-                _I_ =  /*<<arg.ml:124:11>>*/ [0, caml_call1(Stdlib[32], arg)],
+                _I_ =  /*<<arg.ml:124:11>>*/ [0, Stdlib[32].call(null, arg)],
                 match = _I_;
               }
               catch(exn$0){
@@ -21380,15 +21181,15 @@
              case 10:
               var specs =  /*<<arg.ml:193:31>>*/ param[1];
                /*<<arg.ml:249:12>>*/ no_arg$0(0);
-               /*<<arg.ml:249:21>>*/ return caml_call2
-                      (Stdlib_List[18], treat_action$0, specs) /*<<arg.ml:276:54>>*/ ;
+               /*<<arg.ml:249:21>>*/ return Stdlib_List[18].call
+                      (null, treat_action$0, specs) /*<<arg.ml:276:54>>*/ ;
              case 11:
               var
                f$4 =  /*<<arg.ml:193:31>>*/ param[2],
                symb = param[1],
                arg$5 =  /*<<arg.ml:209:22>>*/ get_arg$0(0);
                /*<<arg.ml:210:15>>*/ if
-               (caml_call2(Stdlib_List[37], arg$5, symb)){
+               (Stdlib_List[37].call(null, arg$5, symb)){
                 /*<<arg.ml:211:14>>*/ caml_call1(f$4, arg$5);
                 /*<<arg.ml:211:19>>*/ return consume_arg$0(0) /*<<arg.ml:276:54>>*/ ;
               }
@@ -21399,7 +21200,7 @@
                /*<<arg.ml:214:42>>*/ throw caml_maybe_attach_backtrace
                      ([0,
                        Stop,
-                       [1, s$0, arg$5, caml_call2(Stdlib[28], cst_one_of, _J_)]],
+                       [1, s$0, arg$5, Stdlib[28].call(null, cst_one_of, _J_)]],
                       1);
              case 12:
               var f$5 =  /*<<arg.ml:193:31>>*/ param[1];
@@ -21422,7 +21223,7 @@
                if(current[1] >= (argv[1].length - 2 | 0))
                  /*<<arg.ml:264:14>>*/ return  /*<<arg.ml:264:29>>*/ caml_call1
                         (f$6,
-                          /*<<arg.ml:264:14>>*/ caml_call1(Stdlib_List[10], acc[1])) /*<<arg.ml:276:54>>*/ ;
+                          /*<<arg.ml:264:14>>*/ Stdlib_List[10].call(null, acc[1])) /*<<arg.ml:276:54>>*/ ;
                var
                 _H_ =  /*<<arg.ml:261:14>>*/ current[1] + 1 | 0,
                 _K_ =  /*<<arg.ml:261:21>>*/ acc[1];
@@ -21441,17 +21242,17 @@
                /*<<arg.ml:271:12>>*/ consume_arg$0(0);
               var
                before =
-                  /*<<arg.ml:272:25>>*/ caml_call3
-                  (Stdlib_Array[6], argv[1], 0, current[1] + 1 | 0),
+                  /*<<arg.ml:272:25>>*/ Stdlib_Array[6].call
+                  (null, argv[1], 0, current[1] + 1 | 0),
                after =
-                  /*<<arg.ml:274:14>>*/ caml_call3
-                  (Stdlib_Array[6],
+                  /*<<arg.ml:274:14>>*/ Stdlib_Array[6].call
+                  (null,
                    argv[1],
                    current[1] + 1 | 0,
                    (argv[1].length - 1 - current[1] | 0) - 1 | 0);
                /*<<arg.ml:276:19>>*/ argv[1] =
-               caml_call1
-                (Stdlib_Array[5], [0, before, [0, newarg, [0, after, 0]]]);
+               Stdlib_Array[5].call
+                (null, [0, before, [0, newarg, [0, after, 0]]]);
                /*<<arg.ml:276:53>>*/ return 0;
            }
            /*<<arg.ml:276:54>>*/ };
@@ -21506,14 +21307,16 @@
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0), tag = exn[1];
      if(tag === Bad){
       var msg$0 = exn[2];
-       /*<<arg.ml:302:15>>*/ caml_call2(Stdlib_Printf[3], _l_, msg$0);
-       /*<<arg.ml:302:31>>*/ return caml_call1(Stdlib[99], 2) /*<<arg.ml:303:39>>*/ ;
+       /*<<arg.ml:302:15>>*/ caml_call1
+       (Stdlib_Printf[3].call(null, _l_), msg$0);
+       /*<<arg.ml:302:31>>*/ return Stdlib[99].call(null, 2) /*<<arg.ml:303:39>>*/ ;
      }
      var tag$0 =  /*<<?>>*/ exn[1];
      if(tag$0 !== Help) throw caml_maybe_attach_backtrace(exn, 0);
      var msg$1 = exn[2];
-      /*<<arg.ml:303:16>>*/ caml_call2(Stdlib_Printf[2], _m_, msg$1);
-      /*<<arg.ml:303:31>>*/ return caml_call1(Stdlib[99], 0) /*<<arg.ml:303:39>>*/ ;
+      /*<<arg.ml:303:16>>*/ caml_call1
+      (Stdlib_Printf[2].call(null, _m_), msg$1);
+      /*<<arg.ml:303:31>>*/ return Stdlib[99].call(null, 0) /*<<arg.ml:303:39>>*/ ;
     }
    }
    function parse_dynamic(l, f, msg){
@@ -21528,14 +21331,16 @@
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0), tag = exn[1];
      if(tag === Bad){
       var msg$0 = exn[2];
-       /*<<arg.ml:310:15>>*/ caml_call2(Stdlib_Printf[3], _n_, msg$0);
-       /*<<arg.ml:310:31>>*/ return caml_call1(Stdlib[99], 2) /*<<arg.ml:311:39>>*/ ;
+       /*<<arg.ml:310:15>>*/ caml_call1
+       (Stdlib_Printf[3].call(null, _n_), msg$0);
+       /*<<arg.ml:310:31>>*/ return Stdlib[99].call(null, 2) /*<<arg.ml:311:39>>*/ ;
      }
      var tag$0 =  /*<<?>>*/ exn[1];
      if(tag$0 !== Help) throw caml_maybe_attach_backtrace(exn, 0);
      var msg$1 = exn[2];
-      /*<<arg.ml:311:16>>*/ caml_call2(Stdlib_Printf[2], _o_, msg$1);
-      /*<<arg.ml:311:31>>*/ return caml_call1(Stdlib[99], 0) /*<<arg.ml:311:39>>*/ ;
+      /*<<arg.ml:311:16>>*/ caml_call1
+      (Stdlib_Printf[2].call(null, _o_), msg$1);
+      /*<<arg.ml:311:31>>*/ return Stdlib[99].call(null, 0) /*<<arg.ml:311:39>>*/ ;
     }
    }
    function parse_expand(l, f, msg){
@@ -21553,14 +21358,16 @@
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0), tag = exn[1];
      if(tag === Bad){
       var msg$0 = exn[2];
-       /*<<arg.ml:320:15>>*/ caml_call2(Stdlib_Printf[3], _p_, msg$0);
-       /*<<arg.ml:320:31>>*/ return caml_call1(Stdlib[99], 2) /*<<arg.ml:321:39>>*/ ;
+       /*<<arg.ml:320:15>>*/ caml_call1
+       (Stdlib_Printf[3].call(null, _p_), msg$0);
+       /*<<arg.ml:320:31>>*/ return Stdlib[99].call(null, 2) /*<<arg.ml:321:39>>*/ ;
      }
      var tag$0 =  /*<<?>>*/ exn[1];
      if(tag$0 !== Help) throw caml_maybe_attach_backtrace(exn, 0);
      var msg$1 = exn[2];
-      /*<<arg.ml:321:16>>*/ caml_call2(Stdlib_Printf[2], _q_, msg$1);
-      /*<<arg.ml:321:31>>*/ return caml_call1(Stdlib[99], 0) /*<<arg.ml:321:39>>*/ ;
+      /*<<arg.ml:321:16>>*/ caml_call1
+      (Stdlib_Printf[2].call(null, _q_), msg$1);
+      /*<<arg.ml:321:31>>*/ return Stdlib[99].call(null, 0) /*<<arg.ml:321:39>>*/ ;
     }
    }
    function second_word(s){
@@ -21576,12 +21383,12 @@
      }
      /*<<arg.ml:329:10>>*/ }
      /*<<arg.ml:331:2>>*/ try{
-     var n$0 =  /*<<arg.ml:331:8>>*/ caml_call2(Stdlib_String[36], s, 9);
+     var n$0 =  /*<<arg.ml:331:8>>*/ Stdlib_String[36].call(null, s, 9);
     }
     catch(exn$1){
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$1);
      if(exn !== Stdlib[8]) throw caml_maybe_attach_backtrace(exn, 0);
-     try{var n =  /*<<arg.ml:334:18>>*/ caml_call2(Stdlib_String[36], s, 32);}
+     try{var n =  /*<<arg.ml:334:18>>*/ Stdlib_String[36].call(null, s, 32);}
      catch(exn){
       var exn$0 =  /*<<?>>*/ caml_wrap_exception(exn);
       if(exn$0 === Stdlib[8])  /*<<arg.ml:336:31>>*/ return len;
@@ -21597,19 +21404,19 @@
      spec = param[2],
      kwd = param[1];
      /*<<arg.ml:341:2>>*/ if(11 === spec[0])
-      /*<<arg.ml:342:16>>*/ return caml_call2
-             (Stdlib_Int[11], cur, caml_ml_string_length(kwd)) /*<<arg.ml:343:58>>*/ ;
+      /*<<arg.ml:342:16>>*/ return Stdlib_Int[11].call
+             (null, cur, caml_ml_string_length(kwd)) /*<<arg.ml:343:58>>*/ ;
     var
      _E_ =
         /*<<arg.ml:343:57>>*/ caml_ml_string_length(kwd)
        +  /*<<arg.ml:343:42>>*/ second_word(doc)
        | 0;
-     /*<<arg.ml:343:57>>*/ return caml_call2(Stdlib_Int[11], cur, _E_) /*<<arg.ml:343:58>>*/ ;
+     /*<<arg.ml:343:57>>*/ return Stdlib_Int[11].call(null, cur, _E_) /*<<arg.ml:343:58>>*/ ;
    }
    function replace_leading_tab(s){
     var seen =  /*<<arg.ml:347:2>>*/ [0, 0];
-     /*<<arg.ml:348:2>>*/ return caml_call2
-            (Stdlib_String[18],
+     /*<<arg.ml:348:2>>*/ return Stdlib_String[18].call
+            (null,
              function(c){
                /*<<arg.ml:348:13>>*/ if(9 === c && ! seen[1]){
                 /*<<arg.ml:348:46>>*/ seen[1] = 1;
@@ -21624,11 +21431,11 @@
      limit =  /*<<arg.ml:373:10>>*/ opt ? opt[1] : Stdlib[19],
      completed =  /*<<arg.ml:374:18>>*/ add_help(speclist),
      len =
-        /*<<arg.ml:375:12>>*/ caml_call3
-        (Stdlib_List[26], max_arg_len, 0, completed),
-     len$0 =  /*<<arg.ml:376:12>>*/ caml_call2(Stdlib_Int[10], len, limit);
-     /*<<arg.ml:377:28>>*/ return caml_call2
-            (Stdlib_List[20],
+        /*<<arg.ml:375:12>>*/ Stdlib_List[26].call
+        (null, max_arg_len, 0, completed),
+     len$0 =  /*<<arg.ml:376:12>>*/ Stdlib_Int[10].call(null, len, limit);
+     /*<<arg.ml:377:28>>*/ return Stdlib_List[20].call
+            (null,
              function(ksd){
               var kwd =  /*<<arg.ml:351:2>>*/ ksd[1], spec = ksd[2];
               if(ksd[3] === cst$8)  /*<<arg.ml:355:6>>*/ return ksd;
@@ -21637,19 +21444,19 @@
                 msg$0 = ksd[3],
                 cutcol$0 =  /*<<arg.ml:357:19>>*/ second_word(msg$0),
                 _C_ =
-                   /*<<arg.ml:358:32>>*/ caml_call2
-                   (Stdlib_Int[11], 0, len$0 - cutcol$0 | 0)
+                   /*<<arg.ml:358:32>>*/ Stdlib_Int[11].call
+                   (null, 0, len$0 - cutcol$0 | 0)
                   + 3
                   | 0,
                 spaces$0 =
-                   /*<<arg.ml:358:19>>*/ caml_call2(Stdlib_String[1], _C_, 32),
+                   /*<<arg.ml:358:19>>*/ Stdlib_String[1].call(null, _C_, 32),
                 _D_ =  /*<<arg.ml:359:34>>*/ replace_leading_tab(msg$0),
                 _E_ =
-                   /*<<arg.ml:359:25>>*/ caml_call2(Stdlib[28], spaces$0, _D_);
+                   /*<<arg.ml:359:25>>*/ Stdlib[28].call(null, spaces$0, _D_);
                 /*<<arg.ml:359:18>>*/ return [0,
                        kwd,
                        spec,
-                       caml_call2(Stdlib[28], cst$7, _E_)] /*<<arg.ml:359:57>>*/ ;
+                       Stdlib[28].call(null, cst$7, _E_)] /*<<arg.ml:359:57>>*/ ;
               }
               var
                msg =  /*<<arg.ml:351:2>>*/ ksd[3],
@@ -21664,34 +21471,35 @@
                        replace_leading_tab(msg)] /*<<arg.ml:365:43>>*/ ;
               var
                spaces =
-                  /*<<arg.ml:367:21>>*/ caml_call2(Stdlib_String[1], diff, 32),
+                  /*<<arg.ml:367:21>>*/ Stdlib_String[1].call(null, diff, 32),
                _A_ =  /*<<arg.ml:368:32>>*/ replace_leading_tab(msg),
                prefix =
-                  /*<<arg.ml:368:21>>*/ caml_call3
-                  (Stdlib_String[16], _A_, 0, cutcol),
+                  /*<<arg.ml:368:21>>*/ Stdlib_String[16].call
+                  (null, _A_, 0, cutcol),
                suffix =
-                  /*<<arg.ml:369:8>>*/  /*<<arg.ml:369:21>>*/ caml_call3
-                  (Stdlib_String[16],
+                  /*<<arg.ml:369:8>>*/  /*<<arg.ml:369:21>>*/ Stdlib_String
+                   [16].call
+                  (null,
                    msg,
                    cutcol,
                     /*<<arg.ml:369:8>>*/ caml_ml_string_length(msg) - cutcol
                    | 0),
                _B_ =
-                  /*<<arg.ml:370:29>>*/ caml_call2(Stdlib[28], spaces, suffix);
+                  /*<<arg.ml:370:29>>*/ Stdlib[28].call(null, spaces, suffix);
                /*<<arg.ml:370:20>>*/ return [0,
                       kwd,
                       spec$0,
-                      caml_call2(Stdlib[28], prefix, _B_)] /*<<arg.ml:370:44>>*/ ;
+                      Stdlib[28].call(null, prefix, _B_)] /*<<arg.ml:370:44>>*/ ;
              },
              completed) /*<<arg.ml:377:38>>*/ ;
    }
    function read_aux(trim, sep, file){
     var
-     ic =  /*<<arg.ml:387:11>>*/ caml_call1(Stdlib[80], file),
-     buf =  /*<<arg.ml:388:12>>*/ caml_call1(Stdlib_Buffer[1], 200),
+     ic =  /*<<arg.ml:387:11>>*/ Stdlib[80].call(null, file),
+     buf =  /*<<arg.ml:388:12>>*/ Stdlib_Buffer[1].call(null, 200),
      words =  /*<<arg.ml:389:2>>*/ [0, 0];
     function stash(param){
-     var word =  /*<<arg.ml:391:15>>*/ caml_call1(Stdlib_Buffer[2], buf);
+     var word =  /*<<arg.ml:391:15>>*/ Stdlib_Buffer[2].call(null, buf);
       /*<<arg.ml:392:4>>*/ if(trim)
       var
        len =  /*<<arg.ml:380:2>>*/ caml_ml_string_length(word),
@@ -21699,32 +21507,33 @@
           /*<<arg.ml:381:2>>*/ 0 < len
           ? 13
             ===  /*<<arg.ml:381:16>>*/ caml_string_get(word, len - 1 | 0)
-            ?  /*<<arg.ml:382:4>>*/ caml_call3
-              (Stdlib_String[16], word, 0, len - 1 | 0)
+            ?  /*<<arg.ml:382:4>>*/ Stdlib_String
+               [16].call
+              (null, word, 0, len - 1 | 0)
             : word
           : word;
      else
       var word$0 =  /*<<arg.ml:392:4>>*/ word;
       /*<<arg.ml:393:4>>*/ words[1] = [0, word$0, words[1]];
-      /*<<arg.ml:394:4>>*/ return caml_call1(Stdlib_Buffer[8], buf) /*<<arg.ml:394:20>>*/ ;
+      /*<<arg.ml:394:4>>*/ return Stdlib_Buffer[8].call(null, buf) /*<<arg.ml:394:20>>*/ ;
     }
      /*<<arg.ml:396:2>>*/ try{
      for(;;){
-      var c =  /*<<arg.ml:398:16>>*/ caml_call1(Stdlib[82], ic);
+      var c =  /*<<arg.ml:398:16>>*/ Stdlib[82].call(null, ic);
        /*<<arg.ml:399:8>>*/ if(c === sep)
         /*<<arg.ml:399:24>>*/ stash(0);
       else
-        /*<<arg.ml:399:38>>*/ caml_call2(Stdlib_Buffer[12], buf, c);
+        /*<<arg.ml:399:38>>*/ Stdlib_Buffer[12].call(null, buf, c);
      }
     }
     catch(exn$0){
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0);
      if(exn !== Stdlib[12]) throw caml_maybe_attach_backtrace(exn, 0);
-      /*<<arg.ml:403:5>>*/ if(0 < caml_call1(Stdlib_Buffer[7], buf))
+      /*<<arg.ml:403:5>>*/ if(0 < Stdlib_Buffer[7].call(null, buf))
        /*<<arg.ml:403:32>>*/ stash(0);
-      /*<<arg.ml:404:2>>*/ caml_call1(Stdlib[93], ic);
-     var _A_ =  /*<<arg.ml:405:16>>*/ caml_call1(Stdlib_List[10], words[1]);
-      /*<<arg.ml:405:33>>*/ return caml_call1(Stdlib_Array[11], _A_);
+      /*<<arg.ml:404:2>>*/ Stdlib[93].call(null, ic);
+     var _A_ =  /*<<arg.ml:405:16>>*/ Stdlib_List[10].call(null, words[1]);
+      /*<<arg.ml:405:33>>*/ return Stdlib_Array[11].call(null, _A_);
     }
    }
    var _r_ =  /*<<arg.ml:407:15>>*/ 10, _s_ = 1;
@@ -21737,15 +21546,15 @@
      /*<<arg.ml:409:16>>*/ return read_aux(_u_, _t_, _A_);
    }
    function write_aux(sep, file, args){
-    var oc =  /*<<arg.ml:412:11>>*/ caml_call1(Stdlib[61], file);
-     /*<<arg.ml:413:2>>*/ caml_call2
-     (Stdlib_Array[12],
+    var oc =  /*<<arg.ml:412:11>>*/ Stdlib[61].call(null, file);
+     /*<<arg.ml:413:2>>*/ Stdlib_Array[12].call
+     (null,
       function(s){
-        /*<<arg.ml:413:23>>*/ return caml_call4
-               (Stdlib_Printf[1], oc, _v_, s, sep) /*<<arg.ml:413:46>>*/ ;
+        /*<<arg.ml:413:23>>*/ return caml_call2
+               (Stdlib_Printf[1].call(null, oc, _v_), s, sep) /*<<arg.ml:413:46>>*/ ;
       },
       args);
-     /*<<arg.ml:413:52>>*/ return caml_call1(Stdlib[76], oc) /*<<arg.ml:414:14>>*/ ;
+     /*<<arg.ml:413:52>>*/ return Stdlib[76].call(null, oc) /*<<arg.ml:414:14>>*/ ;
    }
    var _w_ =  /*<<arg.ml:416:16>>*/ 10;
    function write_arg(_z_, _A_){return write_aux(_w_, _z_, _A_);}
@@ -21807,20 +21616,15 @@
             ? 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_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_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]);
+   function caml_call7(f, a0, a1, a2, a3, a4, a5, a6){
+    return (f.l >= 0 ? f.l : f.l = f.length) === 7
+            ? f(a0, a1, a2, a3, a4, a5, a6)
+            : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5, a6]);
    }
    var
     global_data = runtime.caml_get_global_data(),
@@ -21851,7 +21655,7 @@
     Stdlib = global_data.Stdlib,
     Stdlib_Buffer = global_data.Stdlib__Buffer,
     Stdlib_Obj = global_data.Stdlib__Obj,
-    printers =  /*<<printexc.ml:20:15>>*/ caml_call1(Stdlib_Atomic[1], 0),
+    printers =  /*<<printexc.ml:20:15>>*/ Stdlib_Atomic[1].call(null, 0),
     _a_ =  /*<<printexc.ml:20:29>>*/ [0, [3, 0, 0], "%S"],
     _b_ = [0, [4, 0, 0, 0, 0], "%d"],
     _c_ = [0, [11, ", ", [2, 0, [2, 0, 0]]], ", %s%s"],
@@ -21903,30 +21707,32 @@
     cst_Program_not_linked_with_g_ = cst_Program_not_linked_with_g_$0;
    function field(x, i){
     var f =  /*<<printexc.ml:25:10>>*/ x[i + 1];
-     /*<<printexc.ml:26:9>>*/ if(! caml_call1(Stdlib_Obj[1], f))
-      /*<<printexc.ml:27:4>>*/ return caml_call2(Stdlib_Printf[4], _b_, f) /*<<printexc.ml:33:7>>*/ ;
-    var _O_ =  /*<<printexc.ml:28:10>>*/ Stdlib_Obj[15];
-    if(caml_obj_tag(f) === _O_)
-      /*<<printexc.ml:29:4>>*/ return caml_call2(Stdlib_Printf[4], _a_, f) /*<<printexc.ml:33:7>>*/ ;
-    var _P_ =  /*<<printexc.ml:30:10>>*/ Stdlib_Obj[16];
-    return caml_obj_tag(f) === _P_
-            ?  /*<<printexc.ml:31:4>>*/ caml_call1(Stdlib[35], f)
+     /*<<printexc.ml:26:9>>*/ if(! Stdlib_Obj[1].call(null, f))
+      /*<<printexc.ml:27:4>>*/ return caml_call1
+             (Stdlib_Printf[4].call(null, _b_), f) /*<<printexc.ml:33:7>>*/ ;
+    var _R_ =  /*<<printexc.ml:28:10>>*/ Stdlib_Obj[15];
+    if(caml_obj_tag(f) === _R_)
+      /*<<printexc.ml:29:4>>*/ return caml_call1
+             (Stdlib_Printf[4].call(null, _a_), f) /*<<printexc.ml:33:7>>*/ ;
+    var _S_ =  /*<<printexc.ml:30:10>>*/ Stdlib_Obj[16];
+    return caml_obj_tag(f) === _S_
+            ?  /*<<printexc.ml:31:4>>*/ Stdlib[35].call(null, 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;
     var
-     _N_ =  /*<<printexc.ml:37:36>>*/ other_fields(x, i + 1 | 0),
-     _O_ =  /*<<printexc.ml:37:24>>*/ field(x, i);
-     /*<<printexc.ml:37:35>>*/ return caml_call3
-            (Stdlib_Printf[4], _c_, _O_, _N_) /*<<printexc.ml:37:58>>*/ ;
+     _Q_ =  /*<<printexc.ml:37:36>>*/ other_fields(x, i + 1 | 0),
+     _R_ =  /*<<printexc.ml:37:24>>*/ field(x, i);
+     /*<<printexc.ml:37:35>>*/ return caml_call2
+            (Stdlib_Printf[4].call(null, _c_), _R_, _Q_) /*<<printexc.ml:37:58>>*/ ;
    }
    function use_printers(x){
     var
      param =
-        /*<<printexc.ml:53:28>>*/  /*<<printexc.ml:53:7>>*/ caml_call1
-        (Stdlib_Atomic[3], printers);
+        /*<<printexc.ml:53:28>>*/  /*<<printexc.ml:53:7>>*/ Stdlib_Atomic[3].call
+        (null, printers);
      /*<<printexc.ml:53:28>>*/ for(;;){
       /*<<printexc.ml:47:17>>*/ if(! param)
        /*<<printexc.ml:52:12>>*/ return 0;
@@ -21934,7 +21740,7 @@
       /*<<printexc.ml:49:8>>*/ try{
       var val =  /*<<printexc.ml:49:15>>*/ caml_call1(hd, x);
      }
-     catch(_N_){ /*<<?>>*/ param = tl; continue;}
+     catch(_Q_){ /*<<?>>*/ param = tl; continue;}
       /*<<printexc.ml:49:8>>*/ if(val){
       var s = val[1];
        /*<<printexc.ml:51:21>>*/ return [0, s];
@@ -21949,24 +21755,25 @@
       match =  /*<<printexc.ml:40:2>>*/ t.length - 1;
      if(2 < match >>> 0)
       var
-       _L_ =  /*<<printexc.ml:44:38>>*/ other_fields(t, 2),
-       _M_ =  /*<<printexc.ml:44:26>>*/ field(t, 1),
-       _K_ =
-          /*<<printexc.ml:44:37>>*/ caml_call3
-          (Stdlib_Printf[4], _d_, _M_, _L_);
+       _O_ =  /*<<printexc.ml:44:38>>*/ other_fields(t, 2),
+       _P_ =  /*<<printexc.ml:44:26>>*/ field(t, 1),
+       _N_ =
+          /*<<printexc.ml:44:37>>*/ caml_call2
+          (Stdlib_Printf[4].call(null, _d_), _P_, _O_);
      else
        /*<<printexc.ml:40:2>>*/ switch(match){
         case 2:
          var
-          _N_ =  /*<<printexc.ml:43:24>>*/ field(t, 1),
-          _K_ =
-             /*<<printexc.ml:43:35>>*/ caml_call2(Stdlib_Printf[4], _e_, _N_);
+          _Q_ =  /*<<printexc.ml:43:24>>*/ field(t, 1),
+          _N_ =
+             /*<<printexc.ml:43:35>>*/ caml_call1
+             (Stdlib_Printf[4].call(null, _e_), _Q_);
          break;
         case 0:
-         var _K_ =  /*<<printexc.ml:40:2>>*/ cst$1; break;
-        default: var _K_ = cst$2;
+         var _N_ =  /*<<printexc.ml:40:2>>*/ cst$1; break;
+        default: var _N_ = cst$2;
       }
-     var match$0 =  /*<<printexc.ml:61:33>>*/ [0, constructor, [0, _K_]];
+     var match$0 =  /*<<printexc.ml:61:33>>*/ [0, constructor, [0, _N_]];
     }
     else
      var match$0 =  /*<<printexc.ml:57:31>>*/ [0, t[1], 0];
@@ -21976,7 +21783,7 @@
      /*<<printexc.ml:65:2>>*/ if(! fields_opt)
       /*<<printexc.ml:66:12>>*/ return constructor$0;
     var f =  /*<<printexc.ml:65:2>>*/ fields_opt[1];
-     /*<<printexc.ml:67:14>>*/ return caml_call2(Stdlib[28], constructor$0, f) /*<<printexc.ml:67:29>>*/ ;
+     /*<<printexc.ml:67:14>>*/ return Stdlib[28].call(null, constructor$0, f) /*<<printexc.ml:67:29>>*/ ;
    }
    function to_string_default(x){
      /*<<printexc.ml:69:24>>*/ if(x === Stdlib[9])
@@ -21986,9 +21793,8 @@
     var tag =  /*<<printexc.ml:69:24>>*/ x[1];
     if(tag === Stdlib[4]){
      var match = x[2], char$ = match[3], line = match[2], file = match[1];
-      /*<<printexc.ml:73:6>>*/ return caml_call6
-             (Stdlib_Printf[4],
-              locfmt,
+      /*<<printexc.ml:73:6>>*/ return caml_call5
+             (Stdlib_Printf[4].call(null, locfmt),
               file,
               line,
               char$,
@@ -22002,9 +21808,8 @@
       char$0 = match$0[3],
       line$0 = match$0[2],
       file$0 = match$0[1];
-      /*<<printexc.ml:75:6>>*/ return caml_call6
-             (Stdlib_Printf[4],
-              locfmt,
+      /*<<printexc.ml:75:6>>*/ return caml_call5
+             (Stdlib_Printf[4].call(null, locfmt),
               file$0,
               line$0,
               char$0,
@@ -22019,9 +21824,8 @@
      char$1 = match$1[3],
      line$1 = match$1[2],
      file$1 = match$1[1];
-     /*<<printexc.ml:77:6>>*/ return caml_call6
-            (Stdlib_Printf[4],
-             locfmt,
+     /*<<printexc.ml:77:6>>*/ return caml_call5
+            (Stdlib_Printf[4].call(null, locfmt),
              file$1,
              line$1,
              char$1,
@@ -22037,29 +21841,31 @@
     /*<<printexc.ml:84:31>>*/ }
    function print(fct, arg){
      /*<<printexc.ml:87:2>>*/ try{
-     var _K_ =  /*<<printexc.ml:88:4>>*/ caml_call1(fct, arg);
-     return _K_;
+     var _N_ =  /*<<printexc.ml:88:4>>*/ caml_call1(fct, arg);
+     return _N_;
     }
     catch(x$0){
      var
       x =  /*<<?>>*/ caml_wrap_exception(x$0),
-      _J_ =  /*<<printexc.ml:90:39>>*/ to_string(x);
-      /*<<printexc.ml:90:4>>*/ caml_call2(Stdlib_Printf[3], _f_, _J_);
-      /*<<printexc.ml:91:4>>*/ caml_call1(Stdlib[63], Stdlib[40]);
+      _M_ =  /*<<printexc.ml:90:39>>*/ to_string(x);
+      /*<<printexc.ml:90:4>>*/ caml_call1
+      (Stdlib_Printf[3].call(null, _f_), _M_);
+      /*<<printexc.ml:91:4>>*/ Stdlib[63].call(null, Stdlib[40]);
       /*<<printexc.ml:91:16>>*/ throw caml_maybe_attach_backtrace(x, 0);
     }
     /*<<printexc.ml:92:11>>*/ }
    function catch$(fct, arg){
      /*<<printexc.ml:95:2>>*/ try{
-     var _J_ =  /*<<printexc.ml:96:4>>*/ caml_call1(fct, arg);
-     return _J_;
+     var _M_ =  /*<<printexc.ml:96:4>>*/ caml_call1(fct, arg);
+     return _M_;
     }
     catch(x$0){
      var x =  /*<<?>>*/ caml_wrap_exception(x$0);
-      /*<<printexc.ml:98:4>>*/ caml_call1(Stdlib[63], Stdlib[39]);
-     var _I_ =  /*<<printexc.ml:99:39>>*/ to_string(x);
-      /*<<printexc.ml:99:4>>*/ caml_call2(Stdlib_Printf[3], _g_, _I_);
-      /*<<printexc.ml:99:52>>*/ return caml_call1(Stdlib[99], 2) /*<<printexc.ml:100:10>>*/ ;
+      /*<<printexc.ml:98:4>>*/ Stdlib[63].call(null, Stdlib[39]);
+     var _L_ =  /*<<printexc.ml:99:39>>*/ to_string(x);
+      /*<<printexc.ml:99:4>>*/ caml_call1
+      (Stdlib_Printf[3].call(null, _g_), _L_);
+      /*<<printexc.ml:99:52>>*/ return Stdlib[99].call(null, 2) /*<<printexc.ml:100:10>>*/ ;
     }
    }
    function raw_backtrace_entries(bt){
@@ -22075,37 +21881,51 @@
              ? 0 === pos ? cst_Raised_at : cst_Re_raised_at
              : 0 === pos ? cst_Raised_by_primitive_operat : cst_Called_from /*<<printexc.ml:146:75>>*/ ;
     }
-     /*<<printexc.ml:148:2>>*/ if(0 === slot[0]){
+     /*<<printexc.ml:148:2>>*/ if(0 !== slot[0]){
+      /*<<printexc.ml:150:6>>*/ if(slot[1])
+       /*<<printexc.ml:151:50>>*/ return 0;
+     var _L_ =  /*<<printexc.ml:153:44>>*/ info(0);
+      /*<<printexc.ml:153:13>>*/ return [0,
+             caml_call1(Stdlib_Printf[4].call(null, _k_), _L_)] /*<<printexc.ml:153:57>>*/ ;
+    }
+     /*<<printexc.ml:155:6>>*/ if(slot[3] === slot[6])
      var
+      _C_ =  /*<<printexc.ml:157:10>>*/ slot[3],
       lines =
-         /*<<printexc.ml:155:6>>*/ slot[3] === slot[6]
-         ?  /*<<printexc.ml:157:10>>*/ caml_call2
-           (Stdlib_Printf[4], _h_, slot[3])
-         :  /*<<printexc.ml:159:10>>*/ caml_call3
-           (Stdlib_Printf[4], _j_, slot[3], slot[6]),
-      _C_ =  /*<<printexc.ml:161:6>>*/ slot[7],
-      _D_ = slot[4],
-      _E_ = slot[8] ? cst_inlined : cst$3,
-      _F_ =  /*<<printexc.ml:162:14>>*/ slot[2],
-      _G_ = slot[9],
-      _H_ = info(slot[1]);
-      /*<<printexc.ml:161:11>>*/ return [0,
-             caml_call8
-              (Stdlib_Printf[4], _i_, _H_, _G_, _F_, _E_, lines, _D_, _C_)] /*<<printexc.ml:164:44>>*/ ;
-    }
-     /*<<printexc.ml:150:6>>*/ if(slot[1])
-      /*<<printexc.ml:151:50>>*/ return 0;
-    var _I_ =  /*<<printexc.ml:153:44>>*/ info(0);
-     /*<<printexc.ml:153:13>>*/ return [0,
-            caml_call2(Stdlib_Printf[4], _k_, _I_)] /*<<printexc.ml:153:57>>*/ ;
-    /*<<printexc.ml:164:44>>*/ }
+         /*<<printexc.ml:157:43>>*/  /*<<printexc.ml:157:10>>*/ caml_call1
+         (Stdlib_Printf[4].call(null, _h_), _C_);
+    else
+     var
+      _J_ =  /*<<printexc.ml:159:10>>*/ slot[6],
+      _K_ = slot[3],
+      lines =
+         /*<<printexc.ml:159:58>>*/  /*<<printexc.ml:159:10>>*/ caml_call2
+         (Stdlib_Printf[4].call(null, _j_), _K_, _J_);
+    var
+     _D_ =  /*<<printexc.ml:161:6>>*/ slot[7],
+     _E_ = slot[4],
+     _F_ = slot[8] ? cst_inlined : cst$3,
+     _G_ =  /*<<printexc.ml:162:14>>*/ slot[2],
+     _H_ = slot[9],
+     _I_ = info(slot[1]);
+     /*<<printexc.ml:161:11>>*/ return [0,
+            caml_call7
+             (Stdlib_Printf[4].call(null, _i_),
+              _I_,
+              _H_,
+              _G_,
+              _F_,
+              lines,
+              _E_,
+              _D_)] /*<<printexc.ml:164:44>>*/ ;
+   }
    function print_raw_backtrace(outchan, raw_backtrace){
     var
      backtrace =
         /*<<printexc.ml:179:36>>*/ convert_raw_backtrace(raw_backtrace);
      /*<<printexc.ml:167:2>>*/ if(! backtrace)
-      /*<<printexc.ml:169:6>>*/ return caml_call2
-             (Stdlib_Printf[1], outchan, _m_) /*<<printexc.ml:179:73>>*/ ;
+      /*<<printexc.ml:169:6>>*/ return Stdlib_Printf[1].call
+             (null, outchan, _m_) /*<<printexc.ml:179:73>>*/ ;
     var
      a =  /*<<printexc.ml:167:2>>*/ backtrace[1],
      _A_ =  /*<<printexc.ml:172:6>>*/ a.length - 2 | 0,
@@ -22119,8 +21939,8 @@
           (i,  /*<<printexc.ml:173:38>>*/ caml_check_bound(a, i)[i + 1]);
        /*<<printexc.ml:173:43>>*/ if(match){
        var str = match[1];
-        /*<<printexc.ml:175:24>>*/ caml_call3
-        (Stdlib_Printf[1], outchan, _l_, str);
+        /*<<printexc.ml:175:24>>*/ caml_call1
+        (Stdlib_Printf[1].call(null, outchan, _l_), str);
       }
       var _C_ =  /*<<printexc.ml:173:43>>*/ i + 1 | 0;
       if(_A_ === i) break;
@@ -22142,7 +21962,7 @@
       /*<<printexc.ml:188:5>>*/ return cst_Program_not_linked_with_g_;
     var
      a =  /*<<printexc.ml:186:2>>*/ backtrace[1],
-     b =  /*<<printexc.ml:190:14>>*/ caml_call1(Stdlib_Buffer[1], 1024),
+     b =  /*<<printexc.ml:190:14>>*/ Stdlib_Buffer[1].call(null, 1024),
      _y_ =  /*<<printexc.ml:191:6>>*/ a.length - 2 | 0,
      _z_ = 0;
     if(_y_ >= 0){
@@ -22154,14 +21974,15 @@
           (i,  /*<<printexc.ml:192:38>>*/ caml_check_bound(a, i)[i + 1]);
        /*<<printexc.ml:192:43>>*/ if(match){
        var str = match[1];
-        /*<<printexc.ml:194:24>>*/ caml_call3(Stdlib_Printf[5], b, _n_, str);
+        /*<<printexc.ml:194:24>>*/ caml_call1
+        (Stdlib_Printf[5].call(null, b, _n_), str);
       }
       var _A_ =  /*<<printexc.ml:192:43>>*/ i + 1 | 0;
       if(_y_ === i) break;
       i = _A_;
      }
     }
-     /*<<printexc.ml:196:6>>*/ return caml_call1(Stdlib_Buffer[2], b) /*<<printexc.ml:199:59>>*/ ;
+     /*<<printexc.ml:196:6>>*/ return Stdlib_Buffer[2].call(null, b) /*<<printexc.ml:199:59>>*/ ;
    }
    function backtrace_slot_is_raise(param){
      /*<<printexc.ml:201:30>>*/ return 0 === param[0] ? param[1] : param[1] /*<<printexc.ml:203:36>>*/ ;
@@ -22223,11 +22044,11 @@
      /*<<printexc.ml:284:2>>*/ for(;;){
      var
       old_printers =
-         /*<<printexc.ml:284:21>>*/ caml_call1(Stdlib_Atomic[3], printers),
+         /*<<printexc.ml:284:21>>*/ Stdlib_Atomic[3].call(null, printers),
       new_printers =  /*<<printexc.ml:285:2>>*/ [0, fn, old_printers],
       success =
-         /*<<printexc.ml:286:16>>*/ caml_call3
-         (Stdlib_Atomic[6], printers, old_printers, new_printers),
+         /*<<printexc.ml:286:16>>*/ Stdlib_Atomic[6].call
+         (null, printers, old_printers, new_printers),
       _x_ =  /*<<printexc.ml:287:2>>*/ 1 - success;
      if(! _x_) return _x_;
     }
@@ -22258,17 +22079,18 @@
        cst_Fatal_error_exception_s];
    function default_uncaught_exception_han(exn, raw_backtrace){
     var _w_ =  /*<<printexc.ml:323:40>>*/ to_string(exn);
-     /*<<printexc.ml:323:2>>*/ caml_call2(Stdlib_Printf[3], _o_, _w_);
+     /*<<printexc.ml:323:2>>*/ caml_call1
+     (Stdlib_Printf[3].call(null, _o_), _w_);
      /*<<printexc.ml:324:2>>*/ print_raw_backtrace(Stdlib[40], raw_backtrace);
     var
      status =  /*<<printexc.ml:325:15>>*/ runtime.caml_ml_debug_info_status(0);
      /*<<printexc.ml:326:2>>*/ if(status < 0){
      var
-      _v_ =  /*<<printexc.ml:327:26>>*/ caml_call1(Stdlib[18], status),
+      _v_ =  /*<<printexc.ml:327:26>>*/ Stdlib[18].call(null, status),
       _x_ =  /*<<printexc.ml:327:18>>*/ caml_check_bound(errors, _v_)[_v_ + 1];
-      /*<<printexc.ml:327:4>>*/ caml_call1(Stdlib[53], _x_);
+      /*<<printexc.ml:327:4>>*/ Stdlib[53].call(null, _x_);
     }
-     /*<<printexc.ml:328:2>>*/ return caml_call1(Stdlib[63], Stdlib[40]) /*<<printexc.ml:328:14>>*/ ;
+     /*<<printexc.ml:328:2>>*/ return Stdlib[63].call(null, Stdlib[40]) /*<<printexc.ml:328:14>>*/ ;
    }
    var
     uncaught_exception_handler =
@@ -22300,7 +22122,7 @@
           ? empty_backtrace
           :  /*<<printexc.ml:338:4>>*/ caml_get_exception_raw_backtra(0);
        /*<<printexc.ml:352:4>>*/ try{
-        /*<<printexc.ml:352:9>>*/ caml_call1(Stdlib[103], 0);
+        /*<<printexc.ml:352:9>>*/ Stdlib[103].call(null, 0);
       }
       catch(exn){}
        /*<<printexc.ml:352:4>>*/ try{
@@ -22316,17 +22138,19 @@
         raw_backtrace$0 =
            /*<<printexc.ml:338:4>>*/ caml_get_exception_raw_backtra(0),
         _t_ =  /*<<printexc.ml:357:44>>*/ to_string(exn$1);
-        /*<<printexc.ml:357:6>>*/ caml_call2(Stdlib_Printf[3], _p_, _t_);
+        /*<<printexc.ml:357:6>>*/ caml_call1
+        (Stdlib_Printf[3].call(null, _p_), _t_);
         /*<<printexc.ml:358:6>>*/ print_raw_backtrace
         (Stdlib[40], raw_backtrace);
        var _u_ =  /*<<printexc.ml:360:8>>*/ to_string(exn$0);
-        /*<<printexc.ml:359:6>>*/ caml_call2(Stdlib_Printf[3], _q_, _u_);
+        /*<<printexc.ml:359:6>>*/ caml_call1
+        (Stdlib_Printf[3].call(null, _q_), _u_);
         /*<<printexc.ml:361:6>>*/ print_raw_backtrace
         (Stdlib[40], raw_backtrace$0);
        var
         _r_ =
-           /*<<printexc.ml:362:18>>*/  /*<<printexc.ml:362:6>>*/ caml_call1
-           (Stdlib[63], Stdlib[40]);
+           /*<<printexc.ml:362:18>>*/  /*<<printexc.ml:362:6>>*/ Stdlib[63].call
+           (null, Stdlib[40]);
       }
       var _s_ = _r_;
      }
@@ -22335,8 +22159,8 @@
       if(exn !== Stdlib[9]) throw caml_maybe_attach_backtrace(exn, 0);
       var
        _s_ =
-          /*<<printexc.ml:365:8>>*/ caml_call1
-          (Stdlib[53], cst_Fatal_error_out_of_memory_);
+          /*<<printexc.ml:365:8>>*/ Stdlib[53].call
+          (null, cst_Fatal_error_out_of_memory_);
      }
      return _s_;
     }
@@ -22428,16 +22252,16 @@
        "Stdlib.Fun.Finally_raised",
        runtime.caml_fresh_oo_id(0)],
     cst_Fun_Finally_raised = "Fun.Finally_raised: ";
-    /*<<fun.ml:24:9>>*/ caml_call1
-    (Stdlib_Printexc[9],
+    /*<<fun.ml:24:9>>*/ Stdlib_Printexc[9].call
+    (null,
      function(param){
       var tag =  /*<<fun.ml:24:38>>*/ param[1];
       if(tag !== Finally_raised)  /*<<fun.ml:26:7>>*/ return 0;
       var
        exn =  /*<<fun.ml:24:38>>*/ param[2],
-       _a_ =  /*<<fun.ml:25:55>>*/ caml_call1(Stdlib_Printexc[1], exn);
+       _a_ =  /*<<fun.ml:25:55>>*/ Stdlib_Printexc[1].call(null, exn);
        /*<<fun.ml:25:29>>*/ return [0,
-              caml_call2(Stdlib[28], cst_Fun_Finally_raised, _a_)] /*<<fun.ml:25:78>>*/ ;
+              Stdlib[28].call(null, cst_Fun_Finally_raised, _a_)] /*<<fun.ml:25:78>>*/ ;
       /*<<fun.ml:26:11>>*/ });
    var dummy = 0;
    function protect(finally$, work){
@@ -22449,7 +22273,7 @@
      catch(e$0){
       var
        e =  /*<<?>>*/ caml_wrap_exception(e$0),
-       bt =  /*<<fun.ml:31:15>>*/ caml_call1(Stdlib_Printexc[12], 0),
+       bt =  /*<<fun.ml:31:15>>*/ Stdlib_Printexc[12].call(null, 0),
        exn =  /*<<fun.ml:32:6>>*/ [0, Finally_raised, e];
       caml_restore_raw_backtrace(exn, bt);
       throw caml_maybe_attach_backtrace(exn, 0);
@@ -22461,7 +22285,7 @@
     catch(work_exn$0){
      var
       work_exn =  /*<<?>>*/ caml_wrap_exception(work_exn$0),
-      work_bt =  /*<<fun.ml:37:20>>*/ caml_call1(Stdlib_Printexc[12], 0);
+      work_bt =  /*<<fun.ml:37:20>>*/ Stdlib_Printexc[12].call(null, 0);
       /*<<fun.ml:38:6>>*/ finally_no_exn(0);
       /*<<fun.ml:38:23>>*/ caml_restore_raw_backtrace(work_exn, work_bt);
      throw caml_maybe_attach_backtrace(work_exn, 0);
@@ -22503,16 +22327,6 @@
             ? 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;
@@ -22597,34 +22411,55 @@
    function eventlog_resume(param){ /*<<gc.ml:66:25>>*/ return 0;
     /*<<gc.ml:66:27>>*/ }
    function print_stat(c){
-    var st =  /*<<gc.ml:71:11>>*/ runtime.caml_gc_stat(0);
-     /*<<gc.ml:72:2>>*/ caml_call3(Stdlib_Printf[1], c, _a_, st[4]);
-     /*<<gc.ml:73:2>>*/ caml_call3(Stdlib_Printf[1], c, _b_, st[5]);
-     /*<<gc.ml:74:2>>*/ caml_call3(Stdlib_Printf[1], c, _c_, st[14]);
-     /*<<gc.ml:75:2>>*/ caml_call3(Stdlib_Printf[1], c, _d_, st[17]);
-     /*<<gc.ml:76:2>>*/ caml_call2(Stdlib_Printf[1], c, _e_);
     var
+     st =  /*<<gc.ml:71:11>>*/ runtime.caml_gc_stat(0),
+     _v_ =  /*<<gc.ml:72:2>>*/ st[4];
+    caml_call1(Stdlib_Printf[1].call(null, c, _a_), _v_);
+    var _w_ =  /*<<gc.ml:73:2>>*/ st[5];
+    caml_call1(Stdlib_Printf[1].call(null, c, _b_), _w_);
+    var _x_ =  /*<<gc.ml:74:2>>*/ st[14];
+    caml_call1(Stdlib_Printf[1].call(null, c, _c_), _x_);
+    var _y_ =  /*<<gc.ml:75:2>>*/ st[17];
+    caml_call1(Stdlib_Printf[1].call(null, c, _d_), _y_);
+     /*<<gc.ml:76:2>>*/ Stdlib_Printf[1].call(null, c, _e_);
+    var
+     _z_ =  /*<<gc.ml:77:25>>*/ st[1],
      l1 =
-        /*<<gc.ml:77:25>>*/  /*<<gc.ml:77:56>>*/ caml_ml_string_length
-        ( /*<<gc.ml:77:25>>*/ caml_call2(Stdlib_Printf[4], _f_, st[1]));
-     /*<<gc.ml:78:2>>*/ caml_call4(Stdlib_Printf[1], c, _g_, l1, st[1]);
-     /*<<gc.ml:79:2>>*/ caml_call4(Stdlib_Printf[1], c, _h_, l1, st[2]);
-     /*<<gc.ml:80:2>>*/ caml_call4(Stdlib_Printf[1], c, _i_, l1, st[3]);
-     /*<<gc.ml:81:2>>*/ caml_call2(Stdlib_Printf[1], c, _j_);
-    var
+        /*<<gc.ml:77:56>>*/ caml_ml_string_length
+        ( /*<<gc.ml:77:25>>*/ caml_call1
+          (Stdlib_Printf[4].call(null, _f_), _z_)),
+     _A_ =  /*<<gc.ml:78:2>>*/ st[1];
+    caml_call2(Stdlib_Printf[1].call(null, c, _g_), l1, _A_);
+    var _B_ =  /*<<gc.ml:79:2>>*/ st[2];
+    caml_call2(Stdlib_Printf[1].call(null, c, _h_), l1, _B_);
+    var _C_ =  /*<<gc.ml:80:2>>*/ st[3];
+    caml_call2(Stdlib_Printf[1].call(null, c, _i_), l1, _C_);
+     /*<<gc.ml:81:2>>*/ Stdlib_Printf[1].call(null, c, _j_);
+    var
+     _D_ =  /*<<gc.ml:82:25>>*/ st[15],
      l2 =
-        /*<<gc.ml:82:25>>*/  /*<<gc.ml:82:57>>*/ caml_ml_string_length
-        ( /*<<gc.ml:82:25>>*/ caml_call2(Stdlib_Printf[4], _k_, st[15]));
-     /*<<gc.ml:83:2>>*/ caml_call4(Stdlib_Printf[1], c, _l_, l2, st[15]);
-     /*<<gc.ml:84:2>>*/ caml_call4(Stdlib_Printf[1], c, _m_, l2, st[6]);
-     /*<<gc.ml:85:2>>*/ caml_call4(Stdlib_Printf[1], c, _n_, l2, st[8]);
-     /*<<gc.ml:86:2>>*/ caml_call4(Stdlib_Printf[1], c, _o_, l2, st[10]);
-     /*<<gc.ml:87:2>>*/ caml_call4(Stdlib_Printf[1], c, _p_, l2, st[12]);
-     /*<<gc.ml:88:2>>*/ caml_call4(Stdlib_Printf[1], c, _q_, l2, st[13]);
-     /*<<gc.ml:89:2>>*/ caml_call2(Stdlib_Printf[1], c, _r_);
-     /*<<gc.ml:90:2>>*/ caml_call3(Stdlib_Printf[1], c, _s_, st[9]);
-     /*<<gc.ml:91:2>>*/ caml_call3(Stdlib_Printf[1], c, _t_, st[11]);
-     /*<<gc.ml:91:46>>*/ return caml_call3(Stdlib_Printf[1], c, _u_, st[7]) /*<<gc.ml:92:46>>*/ ;
+        /*<<gc.ml:82:57>>*/ caml_ml_string_length
+        ( /*<<gc.ml:82:25>>*/ caml_call1
+          (Stdlib_Printf[4].call(null, _k_), _D_)),
+     _E_ =  /*<<gc.ml:83:2>>*/ st[15];
+    caml_call2(Stdlib_Printf[1].call(null, c, _l_), l2, _E_);
+    var _F_ =  /*<<gc.ml:84:2>>*/ st[6];
+    caml_call2(Stdlib_Printf[1].call(null, c, _m_), l2, _F_);
+    var _G_ =  /*<<gc.ml:85:2>>*/ st[8];
+    caml_call2(Stdlib_Printf[1].call(null, c, _n_), l2, _G_);
+    var _H_ =  /*<<gc.ml:86:2>>*/ st[10];
+    caml_call2(Stdlib_Printf[1].call(null, c, _o_), l2, _H_);
+    var _I_ =  /*<<gc.ml:87:2>>*/ st[12];
+    caml_call2(Stdlib_Printf[1].call(null, c, _p_), l2, _I_);
+    var _J_ =  /*<<gc.ml:88:2>>*/ st[13];
+    caml_call2(Stdlib_Printf[1].call(null, c, _q_), l2, _J_);
+     /*<<gc.ml:89:2>>*/ Stdlib_Printf[1].call(null, c, _r_);
+    var _K_ =  /*<<gc.ml:90:2>>*/ st[9];
+    caml_call1(Stdlib_Printf[1].call(null, c, _s_), _K_);
+    var _L_ =  /*<<gc.ml:91:2>>*/ st[11];
+    caml_call1(Stdlib_Printf[1].call(null, c, _t_), _L_);
+    var _M_ =  /*<<gc.ml:91:46>>*/ st[7];
+    return caml_call1(Stdlib_Printf[1].call(null, c, _u_), _M_) /*<<gc.ml:92:46>>*/ ;
    }
    function allocated_bytes(param){
     var
@@ -22635,12 +22470,12 @@
      /*<<gc.ml:97:55>>*/ return (mi + ma - pro) * (Stdlib_Sys[9] / 8 | 0);
    }
    function delete_alarm(a){
-     /*<<gc.ml:115:21>>*/ return caml_call2(Stdlib_Atomic[4], a, 0) /*<<gc.ml:115:39>>*/ ;
+     /*<<gc.ml:115:21>>*/ return Stdlib_Atomic[4].call(null, a, 0) /*<<gc.ml:115:39>>*/ ;
    }
    function create_alarm(f){
-    var alarm =  /*<<gc.ml:119:14>>*/ caml_call1(Stdlib_Atomic[1], 1);
-     /*<<gc.ml:120:2>>*/ caml_call1
-     (Stdlib_Domain[6],
+    var alarm =  /*<<gc.ml:119:14>>*/ Stdlib_Atomic[1].call(null, 1);
+     /*<<gc.ml:120:2>>*/ Stdlib_Domain[6].call
+     (null,
       function(param){
         /*<<gc.ml:120:28>>*/ return delete_alarm(alarm) /*<<gc.ml:120:46>>*/ ;
       });
@@ -22705,21 +22540,6 @@
             ? 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 = global_data.Stdlib,
@@ -22732,10 +22552,10 @@
     open_gen = Stdlib[81];
    function with_open(openfun, s, f){
     var ic =  /*<<in_channel.ml:35:11>>*/ caml_call1(openfun, s);
-     /*<<in_channel.ml:36:2>>*/ return caml_call2
-            (Stdlib_Fun[5],
+     /*<<in_channel.ml:36:2>>*/ return Stdlib_Fun[5].call
+            (null,
              function(param){
-               /*<<in_channel.ml:36:34>>*/ return caml_call1(Stdlib[94], ic) /*<<in_channel.ml:36:58>>*/ ;
+               /*<<in_channel.ml:36:34>>*/ return Stdlib[94].call(null, ic) /*<<in_channel.ml:36:58>>*/ ;
              },
              function(param){
                /*<<in_channel.ml:37:15>>*/ return caml_call1(f, ic) /*<<in_channel.ml:37:19>>*/ ;
@@ -22748,8 +22568,11 @@
      /*<<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:12>>*/ return  /*<<in_channel.ml:46:43>>*/ with_open
-            ( /*<<in_channel.ml:46:12>>*/ caml_call2(Stdlib[81], flags, perm),
+    var _c_ =  /*<<in_channel.ml:46:12>>*/ Stdlib[81];
+     /*<<in_channel.ml:46:43>>*/ return with_open
+            (function(_d_){
+               /*<<in_channel.ml:46:12>>*/ return _c_(flags, perm, _d_);
+             },
              s,
              f) /*<<in_channel.ml:46:47>>*/ ;
    }
@@ -22761,7 +22584,7 @@
     close_noerr = Stdlib[94];
    function input_char(ic){
      /*<<in_channel.ml:55:2>>*/ try{
-     var c =  /*<<in_channel.ml:55:8>>*/ caml_call1(Stdlib[82], ic);
+     var c =  /*<<in_channel.ml:55:8>>*/ Stdlib[82].call(null, ic);
     }
     catch(exn$0){
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0);
@@ -22772,7 +22595,7 @@
     /*<<in_channel.ml:57:33>>*/ }
    function input_byte(ic){
      /*<<in_channel.ml:60:2>>*/ try{
-     var n =  /*<<in_channel.ml:60:8>>*/ caml_call1(Stdlib[87], ic);
+     var n =  /*<<in_channel.ml:60:8>>*/ Stdlib[87].call(null, ic);
     }
     catch(exn$0){
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0);
@@ -22783,7 +22606,7 @@
     /*<<in_channel.ml:62:33>>*/ }
    function input_line(ic){
      /*<<in_channel.ml:65:2>>*/ try{
-     var s =  /*<<in_channel.ml:65:8>>*/ caml_call1(Stdlib[83], ic);
+     var s =  /*<<in_channel.ml:65:8>>*/ Stdlib[83].call(null, ic);
     }
     catch(exn$0){
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0);
@@ -22808,12 +22631,12 @@
        && ( /*<<in_channel.ml:76:33>>*/ caml_ba_dim_1(buf) - len | 0) >= ofs)
       /*<<in_channel.ml:78:7>>*/ return caml_ml_input_bigarray
              (ic, buf, ofs, len) /*<<in_channel.ml:78:43>>*/ ;
-     /*<<in_channel.ml:77:7>>*/ return caml_call1
-            (Stdlib[1], cst_input_bigarray) /*<<in_channel.ml:78:43>>*/ ;
+     /*<<in_channel.ml:77:7>>*/ return Stdlib[1].call
+            (null, cst_input_bigarray) /*<<in_channel.ml:78:43>>*/ ;
    }
    function really_input(ic, buf, pos, len){
      /*<<in_channel.ml:81:2>>*/ try{
-      /*<<in_channel.ml:81:8>>*/ caml_call4(Stdlib[85], ic, buf, pos, len);
+      /*<<in_channel.ml:81:8>>*/ Stdlib[85].call(null, ic, buf, pos, len);
       /*<<in_channel.ml:82:10>>*/ return _a_;
     }
     catch(exn$0){
@@ -22846,12 +22669,12 @@
       len = len$0;
      }
     }
-     /*<<in_channel.ml:95:7>>*/ return caml_call1
-            (Stdlib[1], cst_really_input_bigarray) /*<<in_channel.ml:96:50>>*/ ;
+     /*<<in_channel.ml:95:7>>*/ return Stdlib[1].call
+            (null, cst_really_input_bigarray) /*<<in_channel.ml:96:50>>*/ ;
    }
    function really_input_string(ic, len){
      /*<<in_channel.ml:99:2>>*/ try{
-     var s =  /*<<in_channel.ml:99:8>>*/ caml_call2(Stdlib[86], ic, len);
+     var s =  /*<<in_channel.ml:99:8>>*/ Stdlib[86].call(null, ic, len);
     }
     catch(exn$0){
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0);
@@ -22866,8 +22689,8 @@
       /*<<in_channel.ml:107:4>>*/ if(0 !== len$0){
       var
        r =
-          /*<<in_channel.ml:109:14>>*/ caml_call4
-          (Stdlib[84], ic, buf, ofs$0, len$0);
+          /*<<in_channel.ml:109:14>>*/ Stdlib[84].call
+          (null, ic, buf, ofs$0, len$0);
        /*<<in_channel.ml:110:6>>*/ if(0 !== r){
        var
         len$1 =  /*<<in_channel.ml:113:8>>*/ len$0 - r | 0,
@@ -22897,19 +22720,20 @@
         : ofs
           < Stdlib_Sys[12]
           ? Stdlib_Sys[12]
-          :  /*<<in_channel.ml:145:8>>*/ caml_call1
-            (Stdlib[2], cst_In_channel_input_all_chann),
+          :  /*<<in_channel.ml:145:8>>*/ Stdlib
+             [2].call
+            (null, cst_In_channel_input_all_chann),
      new_buf =  /*<<in_channel.ml:148:18>>*/ caml_create_bytes(new_len$1);
-     /*<<in_channel.ml:149:4>>*/ caml_call5
-     (Stdlib_Bytes[11], buf, 0, new_buf, 0, ofs);
+     /*<<in_channel.ml:149:4>>*/ Stdlib_Bytes[11].call
+     (null, buf, 0, new_buf, 0, ofs);
      /*<<in_channel.ml:149:34>>*/ return new_buf;
     /*<<in_channel.ml:151:5>>*/ }
    function input_all(ic){
     var chunk_size =  /*<<in_channel.ml:154:2>>*/ 65536;
      /*<<in_channel.ml:155:2>>*/ try{
      var
-      _b_ =  /*<<in_channel.ml:157:36>>*/ caml_call1(Stdlib[91], ic),
-      _c_ =  /*<<in_channel.ml:157:6>>*/ caml_call1(Stdlib[92], ic) - _b_ | 0,
+      _b_ =  /*<<in_channel.ml:157:36>>*/ Stdlib[91].call(null, ic),
+      _c_ =  /*<<in_channel.ml:157:6>>*/ Stdlib[92].call(null, ic) - _b_ | 0,
       initial_size = _c_;
     }
     catch(exn$0){
@@ -22930,15 +22754,15 @@
      nread =
         /*<<in_channel.ml:169:14>>*/ read_upto(ic, buf, 0, initial_size$1);
      /*<<in_channel.ml:170:2>>*/ if(nread < initial_size$1)
-      /*<<in_channel.ml:171:4>>*/ return caml_call3
-             (Stdlib_Bytes[8], buf, 0, nread) /*<<in_channel.ml:193:5>>*/ ;
+      /*<<in_channel.ml:171:4>>*/ return Stdlib_Bytes[8].call
+             (null, buf, 0, nread) /*<<in_channel.ml:193:5>>*/ ;
      /*<<in_channel.ml:170:2>>*/ try{
-     var c =  /*<<in_channel.ml:173:10>>*/ caml_call1(Stdlib[82], ic);
+     var c =  /*<<in_channel.ml:173:10>>*/ Stdlib[82].call(null, ic);
     }
     catch(exn){
      var exn$0 =  /*<<?>>*/ caml_wrap_exception(exn);
      if(exn$0 === Stdlib[12])
-       /*<<in_channel.ml:176:8>>*/ return caml_call1(Stdlib_Bytes[44], buf) /*<<in_channel.ml:193:5>>*/ ;
+       /*<<in_channel.ml:176:8>>*/ return Stdlib_Bytes[44].call(null, buf) /*<<in_channel.ml:193:5>>*/ ;
       /*<<?>>*/ throw caml_maybe_attach_backtrace(exn$0, 0);
     }
     var buf$2 =  /*<<in_channel.ml:190:18>>*/ ensure(buf, nread, 65537);
@@ -22954,8 +22778,8 @@
          /*<<in_channel.ml:181:10>>*/ caml_ml_bytes_length(buf$1) - ofs | 0,
       r =  /*<<in_channel.ml:184:18>>*/ read_upto(ic, buf$1, ofs, rem);
       /*<<in_channel.ml:185:10>>*/ if(r < rem)
-       /*<<in_channel.ml:186:12>>*/ return caml_call3
-              (Stdlib_Bytes[8], buf$1, 0, ofs + r | 0) /*<<in_channel.ml:193:5>>*/ ;
+       /*<<in_channel.ml:186:12>>*/ return Stdlib_Bytes[8].call
+              (null, buf$1, 0, ofs + r | 0) /*<<in_channel.ml:193:5>>*/ ;
      var ofs$0 =  /*<<in_channel.ml:188:12>>*/ ofs + rem | 0;
      buf$0 = buf$1;
      ofs = ofs$0;
@@ -22963,7 +22787,7 @@
     /*<<in_channel.ml:193:5>>*/ }
    function input_lines(ic){
      /*<<in_channel.ml:196:2>>*/ try{
-     var line =  /*<<in_channel.ml:196:8>>*/ caml_call1(Stdlib[83], ic);
+     var line =  /*<<in_channel.ml:196:8>>*/ Stdlib[83].call(null, ic);
     }
     catch(exn$0){
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0);
@@ -22976,7 +22800,7 @@
      offset = 1;
     for(;;){
       /*<<in_channel.ml:196:2>>*/ try{
-      var line$0 =  /*<<in_channel.ml:196:8>>*/ caml_call1(Stdlib[83], ic);
+      var line$0 =  /*<<in_channel.ml:196:8>>*/ Stdlib[83].call(null, ic);
      }
      catch(exn){
       var exn$0 =  /*<<?>>*/ caml_wrap_exception(exn);
@@ -22993,7 +22817,7 @@
    function fold_lines(f, accu$1, ic){
     var accu =  /*<<in_channel.ml:201:2>>*/ accu$1;
     for(;;){
-     try{var line =  /*<<in_channel.ml:201:8>>*/ caml_call1(Stdlib[83], ic);}
+     try{var line =  /*<<in_channel.ml:201:8>>*/ Stdlib[83].call(null, ic);}
      catch(exn$0){
       var exn =  /*<<?>>*/ caml_wrap_exception(exn$0);
       if(exn === Stdlib[12])  /*<<in_channel.ml:203:29>>*/ return accu;
@@ -23050,11 +22874,6 @@
             ? 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,
@@ -23066,10 +22885,10 @@
     open_gen = Stdlib[62];
    function with_open(openfun, s, f){
     var oc =  /*<<out_channel.ml:36:11>>*/ caml_call1(openfun, s);
-     /*<<out_channel.ml:37:2>>*/ return caml_call2
-            (Stdlib_Fun[5],
+     /*<<out_channel.ml:37:2>>*/ return Stdlib_Fun[5].call
+            (null,
              function(param){
-               /*<<out_channel.ml:37:34>>*/ return caml_call1(Stdlib[77], oc) /*<<out_channel.ml:37:59>>*/ ;
+               /*<<out_channel.ml:37:34>>*/ return Stdlib[77].call(null, oc) /*<<out_channel.ml:37:59>>*/ ;
              },
              function(param){
                /*<<out_channel.ml:38:15>>*/ return caml_call1(f, oc) /*<<out_channel.ml:38:19>>*/ ;
@@ -23082,8 +22901,11 @@
      /*<<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:12>>*/ return  /*<<out_channel.ml:47:44>>*/ with_open
-            ( /*<<out_channel.ml:47:12>>*/ caml_call2(Stdlib[62], flags, perm),
+    var _a_ =  /*<<out_channel.ml:47:12>>*/ Stdlib[62];
+     /*<<out_channel.ml:47:44>>*/ return with_open
+            (function(_b_){
+               /*<<out_channel.ml:47:12>>*/ return _a_(flags, perm, _b_);
+             },
              s,
              f) /*<<out_channel.ml:47:48>>*/ ;
    }
@@ -23112,8 +22934,8 @@
         >= ofs)
       /*<<out_channel.ml:69:7>>*/ return runtime.caml_ml_output_bigarray
              (oc, buf, ofs, len) /*<<out_channel.ml:69:44>>*/ ;
-     /*<<out_channel.ml:68:7>>*/ return caml_call1
-            (Stdlib[1], cst_output_bigarray) /*<<out_channel.ml:69:44>>*/ ;
+     /*<<out_channel.ml:68:7>>*/ return Stdlib[1].call
+            (null, cst_output_bigarray) /*<<out_channel.ml:69:44>>*/ ;
    }
    var
     set_binary_mode =  /*<<?>>*/ Stdlib[78],
@@ -23176,23 +22998,7 @@
     caml_md5_string = runtime.caml_md5_string,
     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_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
+    caml_string_get = runtime.caml_string_get,
     global_data = runtime.caml_get_global_data(),
     Stdlib = global_data.Stdlib,
     Stdlib_In_channel = global_data.Stdlib__In_channel,
@@ -23211,7 +23017,7 @@
      var
       _i_ =
          /*<<digest.ml:20:4>>*/ 10 <= n ? (97 + n | 0) - 10 | 0 : 48 + n | 0;
-     return caml_call1(Stdlib_Char[1], _i_) /*<<digest.ml:21:52>>*/ ;
+     return Stdlib_Char[1].call(null, _i_) /*<<digest.ml:21:52>>*/ ;
     }
     var
      len =  /*<<digest.ml:22:2>>*/ caml_ml_string_length(d),
@@ -23233,7 +23039,7 @@
       i = _i_;
      }
     }
-     /*<<digest.ml:29:2>>*/ return caml_call1(Stdlib_Bytes[44], result) /*<<digest.ml:29:31>>*/ ;
+     /*<<digest.ml:29:2>>*/ return Stdlib_Bytes[44].call(null, result) /*<<digest.ml:29:31>>*/ ;
    }
    function string_of_hex(s){
     function digit(c){
@@ -23244,10 +23050,10 @@
       else if(71 > c)  /*<<digest.ml:35:18>>*/ return (c - 65 | 0) + 10 | 0;
      }
      else if(9 >= c - 48 >>> 0)  /*<<digest.ml:34:18>>*/ return c - 48 | 0;
-      /*<<digest.ml:37:11>>*/ return caml_call1(Stdlib[1], cst_Digest_of_hex) /*<<digest.ml:37:38>>*/ ;
+      /*<<digest.ml:37:11>>*/ return Stdlib[1].call(null, cst_Digest_of_hex) /*<<digest.ml:37:38>>*/ ;
     }
-     /*<<digest.ml:39:2>>*/ return caml_call2
-            (Stdlib_String[2],
+     /*<<digest.ml:39:2>>*/ return Stdlib_String[2].call
+            (null,
              caml_ml_string_length(s) / 2 | 0,
              function(i){
               var
@@ -23261,14 +23067,14 @@
                  << 4)
                  + _f_
                  | 0;
-               /*<<digest.ml:39:69>>*/ return caml_call1(Stdlib_Char[1], _g_);
+               /*<<digest.ml:39:69>>*/ return Stdlib_Char[1].call(null, _g_);
              }) /*<<digest.ml:39:70>>*/ ;
    }
    function BLAKE2(X){
     var _a_ =  /*<<?>>*/ X[1] < 1 ? 1 : 0, _b_ = _a_ || (64 < X[1] ? 1 : 0);
     if(_b_)
-      /*<<digest.ml:68:9>>*/ caml_call1
-      (Stdlib[1], cst_Digest_BLAKE2_wrong_hash_s);
+      /*<<digest.ml:68:9>>*/ Stdlib[1].call
+      (null, cst_Digest_BLAKE2_wrong_hash_s);
     var
      hash_length =  /*<<digest.ml:69:4>>*/ X[1],
      compare = Stdlib_String[10],
@@ -23290,7 +23096,7 @@
        _f_ = len < 0 ? 1 : 0,
        _e_ = _f_ || ((caml_ml_string_length(str) - len | 0) < ofs ? 1 : 0);
      if(_e_)
-       /*<<digest.ml:94:9>>*/ caml_call1(Stdlib[1], cst_Digest_substring);
+       /*<<digest.ml:94:9>>*/ Stdlib[1].call(null, cst_Digest_substring);
       /*<<digest.ml:95:4>>*/ return caml_blake2_string
              (hash_length, cst, str, ofs, len) /*<<digest.ml:95:44>>*/ ;
     }
@@ -23303,7 +23109,7 @@
        _d_ = len < 0 ? 1 : 0,
        _c_ = _d_ || ((caml_ml_bytes_length(b) - len | 0) < ofs ? 1 : 0);
      if(_c_)
-       /*<<digest.ml:99:9>>*/ caml_call1(Stdlib[1], cst_Digest_subbytes);
+       /*<<digest.ml:99:9>>*/ Stdlib[1].call(null, cst_Digest_subbytes);
       /*<<digest.ml:100:4>>*/ return caml_blake2_bytes
              (hash_length, cst, b, ofs, len) /*<<digest.ml:100:41>>*/ ;
     }
@@ -23320,11 +23126,11 @@
          /*<<digest.ml:115:27>>*/ return caml_blake2_final(ctx, hash_length) /*<<digest.ml:125:7>>*/ ;
        var
         _b_ =
-           /*<<digest.ml:116:44>>*/ caml_call2
-           (Stdlib_Int[10], buf_size, toread$0),
+           /*<<digest.ml:116:44>>*/ Stdlib_Int[10].call
+           (null, buf_size, toread$0),
         n =
-           /*<<digest.ml:116:18>>*/ caml_call4
-           (Stdlib_In_channel[16], ic, buf, 0, _b_);
+           /*<<digest.ml:116:18>>*/ Stdlib_In_channel[16].call
+           (null, ic, buf, 0, _b_);
         /*<<digest.ml:117:10>>*/ if(0 === n)
          /*<<digest.ml:118:15>>*/ throw caml_maybe_attach_backtrace
                (Stdlib[12], 1);
@@ -23337,37 +23143,36 @@
        /*<<digest.ml:106:4>>*/ for(;;){
        var
         n$0 =
-           /*<<digest.ml:108:16>>*/ caml_call4
-           (Stdlib_In_channel[16], ic, buf, 0, buf_size);
+           /*<<digest.ml:108:16>>*/ Stdlib_In_channel[16].call
+           (null, ic, buf, 0, buf_size);
         /*<<digest.ml:109:8>>*/ if(0 === n$0)
          /*<<digest.ml:110:13>>*/ return caml_blake2_final(ctx, hash_length) /*<<digest.ml:125:7>>*/ ;
         /*<<digest.ml:111:14>>*/ caml_blake2_update(ctx, buf, 0, n$0);
       }
      /*<<digest.ml:125:7>>*/ }
     function file(filename){
-      /*<<digest.ml:128:4>>*/ return caml_call2
-             (Stdlib_In_channel[5],
+      /*<<digest.ml:128:4>>*/ return Stdlib_In_channel[5].call
+             (null,
               filename,
               function(ic){
                 /*<<digest.ml:128:49>>*/ return channel(ic, -1) /*<<digest.ml:128:64>>*/ ;
               }) /*<<digest.ml:128:65>>*/ ;
     }
     function output(chan, digest){
-      /*<<digest.ml:130:27>>*/ return caml_call2(Stdlib[66], chan, digest) /*<<digest.ml:130:52>>*/ ;
+      /*<<digest.ml:130:27>>*/ return Stdlib[66].call(null, chan, digest) /*<<digest.ml:130:52>>*/ ;
     }
     function input(chan){
-      /*<<digest.ml:132:19>>*/ return caml_call2
-             (Stdlib[86], chan, hash_length) /*<<digest.ml:132:55>>*/ ;
+      /*<<digest.ml:132:19>>*/ return Stdlib[86].call(null, chan, hash_length) /*<<digest.ml:132:55>>*/ ;
     }
     function to_hex(d){
       /*<<digest.ml:135:4>>*/ if(caml_ml_string_length(d) !== hash_length)
-       /*<<digest.ml:135:43>>*/ caml_call1(Stdlib[1], cst_Digest_to_hex);
+       /*<<digest.ml:135:43>>*/ Stdlib[1].call(null, cst_Digest_to_hex);
       /*<<digest.ml:136:4>>*/ return hex_of_string(d) /*<<digest.ml:136:19>>*/ ;
     }
     function of_hex(s){
       /*<<digest.ml:139:4>>*/ if
       (caml_ml_string_length(s) !== (hash_length * 2 | 0))
-       /*<<digest.ml:139:47>>*/ caml_call1(Stdlib[1], cst_Digest_of_hex$0);
+       /*<<digest.ml:139:47>>*/ Stdlib[1].call(null, cst_Digest_of_hex$0);
       /*<<digest.ml:140:4>>*/ return string_of_hex(s) /*<<digest.ml:140:19>>*/ ;
     }
      /*<<digest.ml:69:4>>*/ return [0,
@@ -23407,38 +23212,38 @@
      /*<<digest.ml:170:4>>*/ if
      (0 <= ofs && 0 <= len && (caml_ml_string_length(str) - len | 0) >= ofs)
       /*<<digest.ml:172:9>>*/ return caml_md5_string(str, ofs, len) /*<<digest.ml:172:34>>*/ ;
-     /*<<digest.ml:171:9>>*/ return caml_call1
-            (Stdlib[1], cst_Digest_substring$0) /*<<digest.ml:172:34>>*/ ;
+     /*<<digest.ml:171:9>>*/ return Stdlib[1].call
+            (null, cst_Digest_substring$0) /*<<digest.ml:172:34>>*/ ;
    }
    function subbytes(b, ofs, len){
      /*<<digest.ml:175:4>>*/ if
      (0 <= ofs && 0 <= len && (caml_ml_bytes_length(b) - len | 0) >= ofs)
       /*<<digest.ml:177:9>>*/ return caml_md5_bytes(b, ofs, len) /*<<digest.ml:177:31>>*/ ;
-     /*<<digest.ml:176:9>>*/ return caml_call1
-            (Stdlib[1], cst_Digest_subbytes$0) /*<<digest.ml:177:31>>*/ ;
+     /*<<digest.ml:176:9>>*/ return Stdlib[1].call
+            (null, cst_Digest_subbytes$0) /*<<digest.ml:177:31>>*/ ;
    }
    function file(filename){
-     /*<<digest.ml:180:4>>*/ return caml_call2
-            (Stdlib_In_channel[5],
+     /*<<digest.ml:180:4>>*/ return Stdlib_In_channel[5].call
+            (null,
              filename,
              function(ic){
                /*<<digest.ml:180:49>>*/ return caml_md5_chan(ic, -1) /*<<digest.ml:180:64>>*/ ;
              }) /*<<digest.ml:180:65>>*/ ;
    }
    function output(chan, digest){
-     /*<<digest.ml:182:27>>*/ return caml_call2(Stdlib[66], chan, digest) /*<<digest.ml:182:52>>*/ ;
+     /*<<digest.ml:182:27>>*/ return Stdlib[66].call(null, chan, digest) /*<<digest.ml:182:52>>*/ ;
    }
    function input(chan){
-     /*<<digest.ml:184:19>>*/ return caml_call2(Stdlib[86], chan, 16) /*<<digest.ml:184:46>>*/ ;
+     /*<<digest.ml:184:19>>*/ return Stdlib[86].call(null, chan, 16) /*<<digest.ml:184:46>>*/ ;
    }
    function to_hex(d){
      /*<<digest.ml:187:4>>*/ if(16 !== caml_ml_string_length(d))
-      /*<<digest.ml:187:34>>*/ caml_call1(Stdlib[1], cst_Digest_to_hex$0);
+      /*<<digest.ml:187:34>>*/ Stdlib[1].call(null, cst_Digest_to_hex$0);
      /*<<digest.ml:188:4>>*/ return hex_of_string(d) /*<<digest.ml:188:19>>*/ ;
    }
    function of_hex(s){
      /*<<digest.ml:191:4>>*/ if(32 !== caml_ml_string_length(s))
-      /*<<digest.ml:191:34>>*/ caml_call1(Stdlib[1], cst_Digest_from_hex);
+      /*<<digest.ml:191:34>>*/ Stdlib[1].call(null, cst_Digest_from_hex);
      /*<<digest.ml:192:4>>*/ return string_of_hex(s) /*<<digest.ml:192:19>>*/ ;
    }
    var
@@ -23648,8 +23453,8 @@
     var
      _U_ =  /*<<bigarray.ml:140:63>>*/ dims(arr),
      _V_ =
-        /*<<bigarray.ml:140:38>>*/ caml_call3
-        (Stdlib_Array[18], caml_mul, 1, _U_);
+        /*<<bigarray.ml:140:38>>*/ Stdlib_Array[18].call
+        (null, caml_mul, 1, _U_);
      /*<<bigarray.ml:140:24>>*/ return  /*<<bigarray.ml:140:35>>*/ caml_mul
             ( /*<<bigarray.ml:140:4>>*/ kind_size_in_bytes
               ( /*<<bigarray.ml:140:24>>*/ caml_ba_kind(arr)),
@@ -23823,8 +23628,8 @@
      for(;;){
       var row =  /*<<bigarray.ml:285:16>>*/ caml_check_bound(data, i)[i + 1];
        /*<<bigarray.ml:286:6>>*/ if(row.length - 1 !== dim2)
-        /*<<bigarray.ml:287:8>>*/ caml_call1
-        (Stdlib[1], cst_Bigarray_Array2_of_array_n);
+        /*<<bigarray.ml:287:8>>*/ Stdlib[1].call
+        (null, cst_Bigarray_Array2_of_array_n);
       var _z_ =  /*<<bigarray.ml:288:6>>*/ dim2 - 1 | 0, _B_ = 0;
       if(_z_ >= 0){
        var j = _B_;
@@ -23970,16 +23775,16 @@
      for(;;){
       var row =  /*<<bigarray.ml:361:16>>*/ caml_check_bound(data, i)[i + 1];
        /*<<bigarray.ml:362:6>>*/ if(row.length - 1 !== dim2)
-        /*<<bigarray.ml:363:8>>*/ caml_call1
-        (Stdlib[1], cst_Bigarray_Array3_of_array_n);
+        /*<<bigarray.ml:363:8>>*/ Stdlib[1].call
+        (null, cst_Bigarray_Array3_of_array_n);
       var _b_ =  /*<<bigarray.ml:364:6>>*/ dim2 - 1 | 0, _e_ = 0;
       if(_b_ >= 0){
        var j = _e_;
        for(;;){
         var col =  /*<<bigarray.ml:365:18>>*/ caml_check_bound(row, j)[j + 1];
          /*<<bigarray.ml:366:8>>*/ if(col.length - 1 !== dim3)
-          /*<<bigarray.ml:367:10>>*/ caml_call1
-          (Stdlib[1], cst_Bigarray_Array3_of_array_n$0);
+          /*<<bigarray.ml:367:10>>*/ Stdlib[1].call
+          (null, cst_Bigarray_Array3_of_array_n$0);
         var _c_ =  /*<<bigarray.ml:368:8>>*/ dim3 - 1 | 0, _g_ = 0;
         if(_c_ >= 0){
          var k = _g_;
@@ -24010,26 +23815,30 @@
    function array0_of_genarray(a){
      /*<<bigarray.ml:385:5>>*/ return 0 === caml_ba_num_dims(a)
             ? a
-            :  /*<<bigarray.ml:386:7>>*/ caml_call1
-              (Stdlib[1], cst_Bigarray_array0_of_genarra) /*<<bigarray.ml:386:48>>*/ ;
+            :  /*<<bigarray.ml:386:7>>*/ Stdlib
+               [1].call
+              (null, cst_Bigarray_array0_of_genarra) /*<<bigarray.ml:386:48>>*/ ;
    }
    function array1_of_genarray(a){
      /*<<bigarray.ml:388:5>>*/ return 1 === caml_ba_num_dims(a)
             ? a
-            :  /*<<bigarray.ml:389:7>>*/ caml_call1
-              (Stdlib[1], cst_Bigarray_array1_of_genarra) /*<<bigarray.ml:389:48>>*/ ;
+            :  /*<<bigarray.ml:389:7>>*/ Stdlib
+               [1].call
+              (null, cst_Bigarray_array1_of_genarra) /*<<bigarray.ml:389:48>>*/ ;
    }
    function array2_of_genarray(a){
      /*<<bigarray.ml:391:5>>*/ return 2 === caml_ba_num_dims(a)
             ? a
-            :  /*<<bigarray.ml:392:7>>*/ caml_call1
-              (Stdlib[1], cst_Bigarray_array2_of_genarra) /*<<bigarray.ml:392:48>>*/ ;
+            :  /*<<bigarray.ml:392:7>>*/ Stdlib
+               [1].call
+              (null, cst_Bigarray_array2_of_genarra) /*<<bigarray.ml:392:48>>*/ ;
    }
    function array3_of_genarray(a){
      /*<<bigarray.ml:394:5>>*/ return 3 === caml_ba_num_dims(a)
             ? a
-            :  /*<<bigarray.ml:395:7>>*/ caml_call1
-              (Stdlib[1], cst_Bigarray_array3_of_genarra) /*<<bigarray.ml:395:48>>*/ ;
+            :  /*<<bigarray.ml:395:7>>*/ Stdlib
+               [1].call
+              (null, cst_Bigarray_array3_of_genarra) /*<<bigarray.ml:395:48>>*/ ;
    }
    function reshape_0(a){
      /*<<bigarray.ml:400:18>>*/ return caml_ba_reshape(a, [0]) /*<<bigarray.ml:400:32>>*/ ;
@@ -24152,11 +23961,6 @@
             ? 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(),
     serialization_prefix = "lxm1:",
@@ -24198,21 +24002,16 @@
       "Random.State.of_binary_string: expected a format compatible with OCaml ";
    function to_binary_string(s){
     var buf =  /*<<random.ml:63:14>>*/ caml_create_bytes(37);
-     /*<<random.ml:64:4>>*/ caml_call5
-     (Stdlib_Bytes[12],
-      serialization_prefix,
-      0,
-      buf,
-      0,
-      serialization_prefix_len);
+     /*<<random.ml:64:4>>*/ Stdlib_Bytes[12].call
+     (null, serialization_prefix, 0, buf, 0, serialization_prefix_len);
     var i =  /*<<random.ml:64:44>>*/ 0;
     for(;;){
      var _u_ =  /*<<random.ml:66:47>>*/ runtime.caml_ba_get_1(s, i);
-      /*<<random.ml:66:6>>*/ caml_call3
-      (Stdlib_Bytes[86], buf, 5 + (i * 8 | 0) | 0, _u_);
+      /*<<random.ml:66:6>>*/ Stdlib_Bytes[86].call
+      (null, buf, 5 + (i * 8 | 0) | 0, _u_);
      var _v_ =  /*<<random.ml:66:63>>*/ i + 1 | 0;
      if(3 === i)
-       /*<<random.ml:68:4>>*/ return caml_call1(Stdlib_Bytes[44], buf) /*<<random.ml:68:30>>*/ ;
+       /*<<random.ml:68:4>>*/ return Stdlib_Bytes[44].call(null, buf) /*<<random.ml:68:30>>*/ ;
       /*<<random.ml:66:63>>*/ i = _v_;
     }
     /*<<random.ml:68:30>>*/ }
@@ -24227,20 +24026,20 @@
        ||
         1
         -
-          /*<<random.ml:74:14>>*/ caml_call2
-          (Stdlib_String[11], serialization_prefix, buf);
+          /*<<random.ml:74:14>>*/ Stdlib_String[11].call
+          (null, serialization_prefix, buf);
      /*<<random.ml:73:4>>*/ if(_t_){
      var
       _u_ =
-         /*<<random.ml:77:8>>*/ caml_call2
-         (Stdlib[28], cst_Random_State_of_binary_str, Stdlib_Sys[46]);
-      /*<<random.ml:76:6>>*/ caml_call1(Stdlib[2], _u_);
+         /*<<random.ml:77:8>>*/ Stdlib[28].call
+         (null, cst_Random_State_of_binary_str, Stdlib_Sys[46]);
+      /*<<random.ml:76:6>>*/ Stdlib[2].call(null, _u_);
     }
     var
-     i1 =  /*<<random.ml:79:13>>*/ caml_call2(Stdlib_String[64], buf, 5),
-     i2 =  /*<<random.ml:80:13>>*/ caml_call2(Stdlib_String[64], buf, 13),
-     i3 =  /*<<random.ml:81:13>>*/ caml_call2(Stdlib_String[64], buf, 21),
-     i4 =  /*<<random.ml:82:13>>*/ caml_call2(Stdlib_String[64], buf, 29);
+     i1 =  /*<<random.ml:79:13>>*/ Stdlib_String[64].call(null, buf, 5),
+     i2 =  /*<<random.ml:80:13>>*/ Stdlib_String[64].call(null, buf, 13),
+     i3 =  /*<<random.ml:81:13>>*/ Stdlib_String[64].call(null, buf, 21),
+     i4 =  /*<<random.ml:82:13>>*/ Stdlib_String[64].call(null, buf, 29);
      /*<<random.ml:83:4>>*/ return mk(i1, i2, i3, i4) /*<<random.ml:83:18>>*/ ;
    }
    function copy(src){
@@ -24261,23 +24060,23 @@
        _r_ =
           /*<<random.ml:100:49>>*/  /*<<random.ml:100:35>>*/ caml_int64_of_int32
           ( /*<<random.ml:100:49>>*/ runtime.caml_check_bound(seed, i)[i + 1]);
-       /*<<random.ml:100:6>>*/ caml_call3(Stdlib_Bytes[86], b, i * 8 | 0, _r_);
+       /*<<random.ml:100:6>>*/ Stdlib_Bytes[86].call(null, b, i * 8 | 0, _r_);
       var _s_ =  /*<<random.ml:100:58>>*/ i + 1 | 0;
       if(_m_ === i) break;
       i = _s_;
      }
     }
      /*<<random.ml:102:4>>*/ caml_bytes_set(b, n * 8 | 0, 1);
-    var d1 =  /*<<random.ml:103:13>>*/ caml_call1(Stdlib_Digest[4], b);
+    var d1 =  /*<<random.ml:103:13>>*/ Stdlib_Digest[4].call(null, b);
      /*<<random.ml:104:4>>*/ caml_bytes_set(b, n * 8 | 0, 2);
     var
-     d2 =  /*<<random.ml:105:13>>*/ caml_call1(Stdlib_Digest[4], b),
-     _o_ =  /*<<random.ml:109:10>>*/ caml_call2(Stdlib_String[64], d2, 8),
-     _p_ =  /*<<random.ml:108:10>>*/ caml_call2(Stdlib_String[64], d2, 0),
-     _q_ =  /*<<random.ml:107:10>>*/ caml_call2(Stdlib_String[64], d1, 8);
+     d2 =  /*<<random.ml:105:13>>*/ Stdlib_Digest[4].call(null, b),
+     _o_ =  /*<<random.ml:109:10>>*/ Stdlib_String[64].call(null, d2, 8),
+     _p_ =  /*<<random.ml:108:10>>*/ Stdlib_String[64].call(null, d2, 0),
+     _q_ =  /*<<random.ml:107:10>>*/ Stdlib_String[64].call(null, d1, 8);
      /*<<random.ml:106:10>>*/ return  /*<<random.ml:106:36>>*/ set
             (s,
-              /*<<random.ml:106:10>>*/ caml_call2(Stdlib_String[64], d1, 0),
+              /*<<random.ml:106:10>>*/ Stdlib_String[64].call(null, d1, 0),
              _q_,
              _p_,
              _o_) /*<<random.ml:109:36>>*/ ;
@@ -24319,12 +24118,11 @@
    function int$(s, bound){
      /*<<random.ml:154:4>>*/ if(1073741823 >= bound && 0 < bound)
       /*<<random.ml:156:9>>*/ return int_aux(s, bound, max_int31) /*<<random.ml:156:34>>*/ ;
-     /*<<random.ml:155:9>>*/ return caml_call1(Stdlib[1], cst_Random_int) /*<<random.ml:156:34>>*/ ;
+     /*<<random.ml:155:9>>*/ return Stdlib[1].call(null, cst_Random_int) /*<<random.ml:156:34>>*/ ;
    }
    function full_int(s, bound){
      /*<<random.ml:161:4>>*/ if(0 >= bound)
-      /*<<random.ml:162:6>>*/ return caml_call1
-             (Stdlib[1], cst_Random_full_int) /*<<random.ml:173:22>>*/ ;
+      /*<<random.ml:162:6>>*/ return Stdlib[1].call(null, cst_Random_full_int) /*<<random.ml:173:22>>*/ ;
     var
      _m_ =
         /*<<random.ml:170:6>>*/ bound <= 1073741823
@@ -24350,7 +24148,7 @@
     /*<<random.ml:201:43>>*/ }
    function int_in_range(s, min, max){
      /*<<random.ml:206:4>>*/ if(max < min)
-      /*<<random.ml:207:6>>*/ caml_call1(Stdlib[1], cst_Random_int_in_range);
+      /*<<random.ml:207:6>>*/ Stdlib[1].call(null, cst_Random_int_in_range);
      /*<<random.ml:214:4>>*/ if(-1073741824 <= min && max <= 1073741823)
       /*<<random.ml:215:6>>*/ return int_in_range_aux
              (s, min, max, max_int31, 31) /*<<random.ml:219:68>>*/ ;
@@ -24376,16 +24174,16 @@
     /*<<random.ml:232:10>>*/ }
    function int32(s, bound){
      /*<<random.ml:235:7>>*/ return caml_lessequal(bound, 0)
-            ?  /*<<random.ml:236:9>>*/ caml_call1(Stdlib[1], cst_Random_int32)
+            ?  /*<<random.ml:236:9>>*/ Stdlib[1].call(null, cst_Random_int32)
             :  /*<<random.ml:237:9>>*/ int32aux(s, bound) /*<<random.ml:237:25>>*/ ;
    }
    function int32_in_range(s, min, max){
      /*<<random.ml:246:7>>*/ if(caml_greaterthan(min, max))
-      /*<<random.ml:247:6>>*/ return caml_call1
-             (Stdlib[1], cst_Random_int32_in_range) /*<<random.ml:254:39>>*/ ;
+      /*<<random.ml:247:6>>*/ return Stdlib[1].call
+             (null, cst_Random_int32_in_range) /*<<random.ml:254:39>>*/ ;
     var
      span =
-        /*<<random.ml:249:17>>*/ caml_call1(Stdlib_Int32[6], max - min | 0);
+        /*<<random.ml:249:17>>*/ Stdlib_Int32[6].call(null, max - min | 0);
      /*<<random.ml:251:9>>*/ if(! caml_lessequal(span, Stdlib_Int32[1]))
       /*<<random.ml:254:22>>*/ return min + int32aux(s, span) | 0 /*<<random.ml:254:39>>*/ ;
      /*<<random.ml:251:27>>*/ for(;;){
@@ -24424,17 +24222,17 @@
     /*<<random.ml:267:10>>*/ }
    function int64(s, bound){
      /*<<random.ml:270:7>>*/ return caml_lessequal(bound, _g_)
-            ?  /*<<random.ml:271:9>>*/ caml_call1(Stdlib[1], cst_Random_int64)
+            ?  /*<<random.ml:271:9>>*/ Stdlib[1].call(null, cst_Random_int64)
             :  /*<<random.ml:272:9>>*/ int64aux(s, bound) /*<<random.ml:272:25>>*/ ;
    }
    function int64_in_range(s, min, max){
      /*<<random.ml:281:7>>*/ if(caml_greaterthan(min, max))
-      /*<<random.ml:282:6>>*/ return caml_call1
-             (Stdlib[1], cst_Random_int64_in_range) /*<<random.ml:289:39>>*/ ;
+      /*<<random.ml:282:6>>*/ return Stdlib[1].call
+             (null, cst_Random_int64_in_range) /*<<random.ml:289:39>>*/ ;
     var
      span =
-        /*<<random.ml:284:28>>*/  /*<<random.ml:284:17>>*/ caml_call1
-        (Stdlib_Int64[6],  /*<<random.ml:284:28>>*/ caml_int64_sub(max, min));
+        /*<<random.ml:284:28>>*/  /*<<random.ml:284:17>>*/ Stdlib_Int64[6].call
+        (null,  /*<<random.ml:284:28>>*/ caml_int64_sub(max, min));
      /*<<random.ml:286:9>>*/ if(! caml_lessequal(span, Stdlib_Int64[1]))
       /*<<random.ml:289:22>>*/ return  /*<<random.ml:289:8>>*/ caml_int64_add
              (min,  /*<<random.ml:289:22>>*/ int64aux(s, span)) /*<<random.ml:289:39>>*/ ;
@@ -24692,7 +24490,7 @@
 
 //# unitInfo: Provides: Stdlib__Hashtbl
 //# unitInfo: Requires: Stdlib, Stdlib__Array, Stdlib__Atomic, Stdlib__Domain, Stdlib__Int, Stdlib__Random, Stdlib__Seq, Stdlib__String, Stdlib__Sys
-//# shape: Stdlib__Hashtbl:[F(2),F(1),F(1),F(1),F(3),F(2),F(2),F(2),F(2),F(2),F(3),F(2),F(2),F(3),F(1)*,F(1),F(1),F(2),F(1),F(1)*->F(1),F(1),F(1),F(2),F(2),F(1),F(1)*,F(1)*,F(1)*,F(2)*,F(3)*,F(4)*]
+//# shape: Stdlib__Hashtbl:[F(2),F(1),F(1),F(1),F(3),F(2),F(2),F(2),F(2),F(2),F(3),F(2),F(2),F(3),F(1)*,F(1),F(1),F(2),F(1),F(1)*->F(1),F(1)*->F(1),F(1)*->F(1),F(2),F(2),F(1),F(1)*,F(1)*,F(1)*,F(2)*,F(3)*,F(4)*]
 (function
   (globalThis){
    "use strict";
@@ -24720,11 +24518,6 @@
             ? 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(),
     _a_ = [0, 0],
@@ -24741,9 +24534,9 @@
    var Stdlib_String = global_data.Stdlib__String;
    function ongoing_traversal(h){
     var
-     _E_ =  /*<<hashtbl.ml:41:2>>*/ h.length - 1 < 4 ? 1 : 0,
-     _F_ = _E_ || (h[4] < 0 ? 1 : 0);
-    return _F_;
+     _K_ =  /*<<hashtbl.ml:41:2>>*/ h.length - 1 < 4 ? 1 : 0,
+     _L_ = _K_ || (h[4] < 0 ? 1 : 0);
+    return _L_;
     /*<<hashtbl.ml:42:23>>*/ }
    function flip_ongoing_traversal(h){
      /*<<hashtbl.ml:45:2>>*/ h[4] = - h[4] | 0;
@@ -24773,16 +24566,16 @@
    }
    var
     randomized_default =
-       /*<<hashtbl.ml:53:2>>*/ caml_call2(Stdlib_String[15], params, 82),
+       /*<<hashtbl.ml:53:2>>*/ Stdlib_String[15].call(null, params, 82),
     randomized =
-       /*<<hashtbl.ml:55:17>>*/ caml_call1
-       (Stdlib_Atomic[1], randomized_default);
+       /*<<hashtbl.ml:55:17>>*/ Stdlib_Atomic[1].call
+       (null, randomized_default);
    function randomize(param){
-     /*<<hashtbl.ml:57:19>>*/ return caml_call2
-            (Stdlib_Atomic[4], randomized, 1) /*<<hashtbl.ml:57:45>>*/ ;
+     /*<<hashtbl.ml:57:19>>*/ return Stdlib_Atomic[4].call
+            (null, randomized, 1) /*<<hashtbl.ml:57:45>>*/ ;
    }
    function is_randomized(param){
-     /*<<hashtbl.ml:58:23>>*/ return caml_call1(Stdlib_Atomic[3], randomized) /*<<hashtbl.ml:58:44>>*/ ;
+     /*<<hashtbl.ml:58:23>>*/ return Stdlib_Atomic[3].call(null, randomized) /*<<hashtbl.ml:58:44>>*/ ;
    }
    var
     prng_key =
@@ -24803,38 +24596,38 @@
      random =
         /*<<hashtbl.ml:73:11>>*/ opt
         ? opt[1]
-        :  /*<<hashtbl.ml:73:22>>*/ caml_call1(Stdlib_Atomic[3], randomized),
+        :  /*<<hashtbl.ml:73:22>>*/ Stdlib_Atomic[3].call(null, randomized),
      s =  /*<<hashtbl.ml:74:10>>*/ power_2_above(16, initial_size);
      /*<<hashtbl.ml:75:2>>*/ if(random)
      var
-      _E_ =
+      _K_ =
          /*<<hashtbl.ml:76:37>>*/ caml_call1(Stdlib_Domain[11][2], prng_key),
       seed =
          /*<<hashtbl.ml:76:62>>*/  /*<<hashtbl.ml:76:19>>*/ caml_call1
-         (Stdlib_Random[19][4], _E_);
+         (Stdlib_Random[19][4], _K_);
     else
      var seed =  /*<<hashtbl.ml:76:68>>*/ 0;
      /*<<hashtbl.ml:78:52>>*/ return [0, 0, caml_array_make(s, 0), seed, s] /*<<hashtbl.ml:78:70>>*/ ;
     /*<<hashtbl.ml:78:72>>*/ }
    function clear(h){
-    var _E_ =  /*<<hashtbl.ml:81:2>>*/ 0 < h[1] ? 1 : 0;
-    return _E_
+    var _K_ =  /*<<hashtbl.ml:81:2>>*/ 0 < h[1] ? 1 : 0;
+    return _K_
             ? (h
                [1]
               = 0,
-               /*<<hashtbl.ml:83:4>>*/ caml_call4
-               (Stdlib_Array[8], h[2], 0, h[2].length - 1, 0))
-            : _E_ /*<<hashtbl.ml:84:5>>*/ ;
+               /*<<hashtbl.ml:83:4>>*/ Stdlib_Array[8].call
+               (null, h[2], 0, h[2].length - 1, 0))
+            : _K_ /*<<hashtbl.ml:84:5>>*/ ;
    }
    function reset(h){
     var len =  /*<<hashtbl.ml:87:2>>*/ h[2].length - 1;
      /*<<hashtbl.ml:88:2>>*/ if
      (4 <= h.length - 1
-      && len !==  /*<<hashtbl.ml:89:13>>*/ caml_call1(Stdlib[18], h[4])){
+      && len !==  /*<<hashtbl.ml:89:13>>*/ Stdlib[18].call(null, h[4])){
       /*<<hashtbl.ml:91:7>>*/ h[1] = 0;
       /*<<hashtbl.ml:93:25>>*/ h[2] =
        /*<<hashtbl.ml:93:14>>*/ caml_array_make
-       ( /*<<hashtbl.ml:93:25>>*/ caml_call1(Stdlib[18], h[4]), 0);
+       ( /*<<hashtbl.ml:93:25>>*/ Stdlib[18].call(null, h[4]), 0);
       /*<<hashtbl.ml:93:51>>*/ return 0;
     }
      /*<<hashtbl.ml:90:4>>*/ return clear(h) /*<<hashtbl.ml:94:5>>*/ ;
@@ -24863,10 +24656,10 @@
     /*<<hashtbl.ml:111:7>>*/ }
    function copy(h){
     var
-     _C_ =  /*<<hashtbl.ml:113:29>>*/ h[4],
-     _D_ = h[3],
-     _E_ = caml_call2(Stdlib_Array[14], copy_bucketlist, h[2]);
-     /*<<hashtbl.ml:113:61>>*/ return [0, h[1], _E_, _D_, _C_];
+     _I_ =  /*<<hashtbl.ml:113:29>>*/ h[4],
+     _J_ = h[3],
+     _K_ = Stdlib_Array[14].call(null, copy_bucketlist, h[2]);
+     /*<<hashtbl.ml:113:61>>*/ return [0, h[1], _K_, _J_, _I_];
     /*<<hashtbl.ml:113:63>>*/ }
    function length(h){
      /*<<hashtbl.ml:115:15>>*/ return h[1];
@@ -24875,10 +24668,10 @@
     var
      nsize =  /*<<hashtbl.ml:118:2>>*/ ndata.length - 1,
      ndata_tail =  /*<<hashtbl.ml:119:19>>*/ caml_array_make(nsize, 0),
-     _w_ =  /*<<hashtbl.ml:135:2>>*/ odata.length - 2 | 0,
-     _z_ = 0;
-    if(_w_ >= 0){
-     var i$0 = _z_;
+     _C_ =  /*<<hashtbl.ml:135:2>>*/ odata.length - 2 | 0,
+     _F_ = 0;
+    if(_C_ >= 0){
+     var i$0 = _F_;
      for(;;){
       var
        cell$1 =
@@ -24903,39 +24696,39 @@
        = cell$0;
         /*<<hashtbl.ml:132:33>>*/ cell = next;
       }
-      var _C_ =  /*<<hashtbl.ml:136:27>>*/ i$0 + 1 | 0;
-      if(_w_ === i$0) break;
-      i$0 = _C_;
+      var _I_ =  /*<<hashtbl.ml:136:27>>*/ i$0 + 1 | 0;
+      if(_C_ === i$0) break;
+      i$0 = _I_;
      }
     }
      /*<<hashtbl.ml:138:2>>*/ if(inplace){
-     var _x_ =  /*<<hashtbl.ml:139:4>>*/ nsize - 1 | 0, _A_ = 0;
-     if(_x_ >= 0){
-      var i = _A_;
+     var _D_ =  /*<<hashtbl.ml:139:4>>*/ nsize - 1 | 0, _G_ = 0;
+     if(_D_ >= 0){
+      var i = _G_;
       for(;;){
        var
         match$0 =
            /*<<hashtbl.ml:140:12>>*/ caml_check_bound(ndata_tail, i)[i + 1];
         /*<<hashtbl.ml:140:26>>*/ if(match$0)
          /*<<hashtbl.ml:142:21>>*/ match$0[3] = 0;
-       var _B_ =  /*<<hashtbl.ml:140:26>>*/ i + 1 | 0;
-       if(_x_ === i) break;
-       i = _B_;
+       var _H_ =  /*<<hashtbl.ml:140:26>>*/ i + 1 | 0;
+       if(_D_ === i) break;
+       i = _H_;
       }
      }
-     var _y_ =  /*<<hashtbl.ml:139:4>>*/ 0;
+     var _E_ =  /*<<hashtbl.ml:139:4>>*/ 0;
     }
     else
-     var _y_ =  /*<<hashtbl.ml:138:2>>*/ inplace;
-    return _y_;
+     var _E_ =  /*<<hashtbl.ml:138:2>>*/ inplace;
+    return _E_;
     /*<<hashtbl.ml:143:8>>*/ }
    function resize(indexfun, h){
     var
      odata =  /*<<hashtbl.ml:146:2>>*/ h[2],
      osize =  /*<<hashtbl.ml:147:2>>*/ odata.length - 1,
      nsize =  /*<<hashtbl.ml:148:2>>*/ osize * 2 | 0,
-     _w_ =  /*<<hashtbl.ml:149:2>>*/ nsize < Stdlib_Sys[13] ? 1 : 0;
-    if(! _w_) return _w_;
+     _C_ =  /*<<hashtbl.ml:149:2>>*/ nsize < Stdlib_Sys[13] ? 1 : 0;
+    if(! _C_) return _C_;
     var
      ndata =  /*<<hashtbl.ml:150:16>>*/ caml_array_make(nsize, 0),
      inplace =  /*<<hashtbl.ml:151:22>>*/ 1 - ongoing_traversal(h);
@@ -24951,9 +24744,9 @@
      /*<<hashtbl.ml:163:2>>*/ if(1 - old_trav)
       /*<<hashtbl.ml:163:23>>*/ flip_ongoing_traversal(h);
      /*<<hashtbl.ml:163:2>>*/ try{
-     var d = h[2], _s_ =  /*<<hashtbl.ml:166:4>>*/ d.length - 2 | 0, _u_ = 0;
-     if(_s_ >= 0){
-      var i = _u_;
+     var d = h[2], _y_ =  /*<<hashtbl.ml:166:4>>*/ d.length - 2 | 0, _A_ = 0;
+     if(_y_ >= 0){
+      var i = _A_;
       for(;;){
        var
         param =
@@ -24966,15 +24759,15 @@
          /*<<hashtbl.ml:161:8>>*/ caml_call2(f, key, data);
          /*<<hashtbl.ml:161:18>>*/ param = next;
        }
-       var _w_ =  /*<<hashtbl.ml:167:21>>*/ i + 1 | 0;
-       if(_s_ === i) break;
-       i = _w_;
+       var _C_ =  /*<<hashtbl.ml:167:21>>*/ i + 1 | 0;
+       if(_y_ === i) break;
+       i = _C_;
       }
      }
      var
-      _t_ =  /*<<hashtbl.ml:169:4>>*/ 1 - old_trav,
-      _v_ = _t_ ?  /*<<hashtbl.ml:169:25>>*/ flip_ongoing_traversal(h) : _t_;
-     return _v_;
+      _z_ =  /*<<hashtbl.ml:169:4>>*/ 1 - old_trav,
+      _B_ = _z_ ?  /*<<hashtbl.ml:169:25>>*/ flip_ongoing_traversal(h) : _z_;
+     return _B_;
     }
     catch(exn$0){
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0);
@@ -24991,9 +24784,9 @@
      /*<<hashtbl.ml:197:2>>*/ if(1 - old_trav)
       /*<<hashtbl.ml:197:23>>*/ flip_ongoing_traversal(h);
      /*<<hashtbl.ml:197:2>>*/ try{
-     var _o_ = d.length - 2 | 0, _q_ = 0;
-     if(_o_ >= 0){
-      var i = _q_;
+     var _u_ = d.length - 2 | 0, _w_ = 0;
+     if(_u_ >= 0){
+      var i = _w_;
       for(;;){
        var
         slot$0 =  /*<<hashtbl.ml:200:44>>*/ caml_check_bound(h[2], i)[i + 1],
@@ -25025,15 +24818,15 @@
          /*<<hashtbl.ml:178:18>>*/ prec[3] = 0;
        else
          /*<<hashtbl.ml:177:17>>*/ caml_check_bound(h[2], i)[i + 1] = 0;
-       var _s_ =  /*<<hashtbl.ml:200:54>>*/ i + 1 | 0;
-       if(_o_ === i) break;
-       i = _s_;
+       var _y_ =  /*<<hashtbl.ml:200:54>>*/ i + 1 | 0;
+       if(_u_ === i) break;
+       i = _y_;
       }
      }
      var
-      _p_ =  /*<<hashtbl.ml:202:4>>*/ 1 - old_trav,
-      _r_ = _p_ ?  /*<<hashtbl.ml:202:25>>*/ flip_ongoing_traversal(h) : _p_;
-     return _r_;
+      _v_ =  /*<<hashtbl.ml:202:4>>*/ 1 - old_trav,
+      _x_ = _v_ ?  /*<<hashtbl.ml:202:25>>*/ flip_ongoing_traversal(h) : _v_;
+     return _x_;
     }
     catch(exn$0){
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0);
@@ -25051,10 +24844,10 @@
      var
       d = h[2],
       accu$1 =  /*<<hashtbl.ml:218:4>>*/ [0, init],
-      _l_ =  /*<<hashtbl.ml:219:4>>*/ d.length - 2 | 0,
-      _m_ = 0;
-     if(_l_ >= 0){
-      var i = _m_;
+      _r_ =  /*<<hashtbl.ml:219:4>>*/ d.length - 2 | 0,
+      _s_ = 0;
+     if(_r_ >= 0){
+      var i = _s_;
       for(;;){
        var
         accu$2 =  /*<<hashtbl.ml:220:6>>*/ accu$1[1],
@@ -25072,15 +24865,15 @@
         accu = accu$0;
        }
         /*<<hashtbl.ml:220:35>>*/ accu$1[1] = accu;
-       var _o_ = i + 1 | 0;
-       if(_l_ === i) break;
-       i = _o_;
+       var _u_ = i + 1 | 0;
+       if(_r_ === i) break;
+       i = _u_;
       }
      }
       /*<<hashtbl.ml:222:4>>*/ if(1 - old_trav)
        /*<<hashtbl.ml:222:25>>*/ flip_ongoing_traversal(h);
-     var _n_ =  /*<<hashtbl.ml:223:4>>*/ accu$1[1];
-     return _n_;
+     var _t_ =  /*<<hashtbl.ml:223:4>>*/ accu$1[1];
+     return _t_;
     }
     catch(exn$0){
      var exn =  /*<<?>>*/ caml_wrap_exception(exn$0);
@@ -25104,17 +24897,17 @@
    function stats(h){
     var
      mbl =
-        /*<<hashtbl.ml:241:4>>*/ caml_call3
-        (Stdlib_Array[18],
+        /*<<hashtbl.ml:241:4>>*/ Stdlib_Array[18].call
+        (null,
          function(m, b){
-          var _l_ =  /*<<hashtbl.ml:241:42>>*/ bucket_length(0, b);
-           /*<<hashtbl.ml:241:61>>*/ return caml_call2(Stdlib_Int[11], m, _l_);
+          var _r_ =  /*<<hashtbl.ml:241:42>>*/ bucket_length(0, b);
+           /*<<hashtbl.ml:241:61>>*/ return Stdlib_Int[11].call(null, m, _r_);
          },
          0,
          h[2]),
      histo =  /*<<hashtbl.ml:242:14>>*/ caml_array_make(mbl + 1 | 0, 0);
-     /*<<hashtbl.ml:243:2>>*/ caml_call2
-     (Stdlib_Array[12],
+     /*<<hashtbl.ml:243:2>>*/ Stdlib_Array[12].call
+     (null,
       function(b){
        var l =  /*<<hashtbl.ml:245:14>>*/ bucket_length(0, b);
         /*<<hashtbl.ml:246:19>>*/ histo[l + 1] =
@@ -25133,8 +24926,8 @@
        var key = buck[1], data = buck[2], next = buck[3];
         /*<<hashtbl.ml:266:41>>*/ return [0,
                [0, key, data],
-               function(_l_){
-                 /*<<hashtbl.ml:266:31>>*/ return aux(i, next, _l_);
+               function(_r_){
+                 /*<<hashtbl.ml:266:31>>*/ return aux(i, next, _r_);
                }] /*<<hashtbl.ml:266:41>>*/ ;
       }
        /*<<hashtbl.ml:262:8>>*/ if(i === tbl_data.length - 1)
@@ -25147,19 +24940,23 @@
       buck = buck$0;
      }
      /*<<hashtbl.ml:266:42>>*/ }
-    var _j_ =  /*<<hashtbl.ml:268:2>>*/ 0, _k_ = 0;
-    return function(_l_){
-      /*<<?>>*/ return aux(_k_, _j_, _l_);} /*<<hashtbl.ml:268:2>>*/ ;
+    var _p_ =  /*<<hashtbl.ml:268:2>>*/ 0, _q_ = 0;
+    return function(_r_){
+      /*<<?>>*/ return aux(_q_, _p_, _r_);} /*<<hashtbl.ml:268:2>>*/ ;
     /*<<hashtbl.ml:268:13>>*/ }
    function to_seq_keys(m){
-    var _j_ =  /*<<hashtbl.ml:270:32>>*/ to_seq(m);
-     /*<<hashtbl.ml:270:42>>*/ return caml_call2
-            (Stdlib_Seq[29], function(_j_){ /*<<?>>*/ return _j_[1];}, _j_) /*<<hashtbl.ml:270:42>>*/ ;
+    var _m_ =  /*<<hashtbl.ml:270:32>>*/ to_seq(m);
+    function _n_(_p_){ /*<<?>>*/ return _p_[1];}
+    var _o_ =  /*<<hashtbl.ml:270:42>>*/ Stdlib_Seq[29];
+    return function(_p_){
+      /*<<?>>*/ return _o_(_n_, _m_, _p_);} /*<<hashtbl.ml:270:42>>*/ ;
    }
    function to_seq_values(m){
     var _j_ =  /*<<hashtbl.ml:272:34>>*/ to_seq(m);
-     /*<<hashtbl.ml:272:44>>*/ return caml_call2
-            (Stdlib_Seq[29], function(_j_){ /*<<?>>*/ return _j_[2];}, _j_) /*<<hashtbl.ml:272:44>>*/ ;
+    function _k_(_m_){ /*<<?>>*/ return _m_[2];}
+    var _l_ =  /*<<hashtbl.ml:272:44>>*/ Stdlib_Seq[29];
+    return function(_m_){
+      /*<<?>>*/ return _l_(_k_, _j_, _m_);} /*<<hashtbl.ml:272:44>>*/ ;
    }
    function MakeSeeded(H){
     function key_index(h, key){
@@ -25382,8 +25179,8 @@
      }
      /*<<hashtbl.ml:457:48>>*/ }
     function add_seq(tbl, i){
-      /*<<hashtbl.ml:460:6>>*/ return caml_call2
-             (Stdlib_Seq[4],
+      /*<<hashtbl.ml:460:6>>*/ return Stdlib_Seq[4].call
+             (null,
               function(param){
                var v =  /*<<hashtbl.ml:460:15>>*/ param[2], k = param[1];
                 /*<<hashtbl.ml:460:29>>*/ return add(tbl, k, v) /*<<hashtbl.ml:460:41>>*/ ;
@@ -25391,8 +25188,8 @@
               i) /*<<hashtbl.ml:460:43>>*/ ;
     }
     function replace_seq(tbl, i){
-      /*<<hashtbl.ml:463:6>>*/ return caml_call2
-             (Stdlib_Seq[4],
+      /*<<hashtbl.ml:463:6>>*/ return Stdlib_Seq[4].call
+             (null,
               function(param){
                var v =  /*<<hashtbl.ml:463:15>>*/ param[2], k = param[1];
                 /*<<hashtbl.ml:463:29>>*/ return replace(tbl, k, v) /*<<hashtbl.ml:463:45>>*/ ;
@@ -25502,8 +25299,9 @@
             ?  /*<<hashtbl.ml:507:7>>*/ caml_hash
               (10, 100, h[3], key)
              & (h[2].length - 2 | 0)
-            :  /*<<hashtbl.ml:508:7>>*/ caml_call1
-              (Stdlib[1], cst_Hashtbl_unsupported_hash_t) /*<<hashtbl.ml:508:59>>*/ ;
+            :  /*<<hashtbl.ml:508:7>>*/ Stdlib
+               [1].call
+              (null, cst_Hashtbl_unsupported_hash_t) /*<<hashtbl.ml:508:59>>*/ ;
    }
    function add(h, key, data){
     var
@@ -25718,8 +25516,8 @@
     }
     /*<<hashtbl.ml:608:44>>*/ }
    function add_seq(tbl, i){
-     /*<<hashtbl.ml:611:2>>*/ return caml_call2
-            (Stdlib_Seq[4],
+     /*<<hashtbl.ml:611:2>>*/ return Stdlib_Seq[4].call
+            (null,
              function(param){
               var v =  /*<<hashtbl.ml:611:11>>*/ param[2], k = param[1];
                /*<<hashtbl.ml:611:25>>*/ return add(tbl, k, v) /*<<hashtbl.ml:611:37>>*/ ;
@@ -25727,8 +25525,8 @@
              i) /*<<hashtbl.ml:611:39>>*/ ;
    }
    function replace_seq(tbl, i){
-     /*<<hashtbl.ml:614:2>>*/ return caml_call2
-            (Stdlib_Seq[4],
+     /*<<hashtbl.ml:614:2>>*/ return Stdlib_Seq[4].call
+            (null,
              function(param){
               var v =  /*<<hashtbl.ml:614:11>>*/ param[2], k = param[1];
                /*<<hashtbl.ml:614:25>>*/ return replace(tbl, k, v) /*<<hashtbl.ml:614:41>>*/ ;
@@ -25745,7 +25543,7 @@
      random =
         /*<<hashtbl.ml:621:12>>*/ opt
         ? opt[1]
-        :  /*<<hashtbl.ml:621:23>>*/ caml_call1(Stdlib_Atomic[3], randomized),
+        :  /*<<hashtbl.ml:621:23>>*/ Stdlib_Atomic[3].call(null, randomized),
      s =  /*<<hashtbl.ml:622:10>>*/ power_2_above(16, h[2].length - 1);
      /*<<hashtbl.ml:623:2>>*/ if(random)
      var
@@ -25838,11 +25636,6 @@
             ? 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 = global_data.Stdlib,
@@ -25862,7 +25655,7 @@
     var
      _A_ =  /*<<weak.ml:28:2>>*/ 0 <= l ? 1 : 0,
      _B_ = _A_ ? l <= Stdlib_Obj[23][15] ? 1 : 0 : _A_;
-    if(1 - _B_)  /*<<weak.ml:29:4>>*/ caml_call1(Stdlib[1], cst_Weak_create);
+    if(1 - _B_)  /*<<weak.ml:29:4>>*/ Stdlib[1].call(null, cst_Weak_create);
      /*<<weak.ml:30:2>>*/ return runtime.caml_weak_create(l) /*<<weak.ml:30:10>>*/ ;
    }
    function length(x){
@@ -25873,7 +25666,7 @@
      _y_ =  /*<<weak.ml:36:2>>*/ 0 <= o ? 1 : 0,
      _A_ = _y_ ? o <  /*<<weak.ml:36:24>>*/ length(e) ? 1 : 0 : _y_,
      _z_ =  /*<<weak.ml:36:2>>*/ 1 - _A_;
-    return _z_ ?  /*<<weak.ml:37:4>>*/ caml_call1(Stdlib[1], msg) : _z_ /*<<weak.ml:37:20>>*/ ;
+    return _z_ ?  /*<<weak.ml:37:4>>*/ Stdlib[1].call(null, msg) : _z_ /*<<weak.ml:37:20>>*/ ;
    }
    function set(e, o, x){
      /*<<weak.ml:42:2>>*/ raise_if_invalid_offset(e, o, cst_Weak_set);
@@ -25911,7 +25704,7 @@
          : _x_;
       /*<<weak.ml:69:7>>*/ return _y_;
     }
-     /*<<weak.ml:68:7>>*/ return caml_call1(Stdlib[1], cst_Weak_blit) /*<<weak.ml:69:40>>*/ ;
+     /*<<weak.ml:68:7>>*/ return Stdlib[1].call(null, cst_Weak_blit) /*<<weak.ml:69:40>>*/ ;
    }
    function fill(ar, ofs, len, x){
      /*<<weak.ml:72:2>>*/ if
@@ -25968,8 +25761,8 @@
      /*<<weak.ml:139:19>>*/ }
     function fold(f, t, init){
      var i =  /*<<weak.ml:149:21>>*/ 0;
-      /*<<weak.ml:149:36>>*/ return caml_call3
-             (Stdlib_Array[20],
+      /*<<weak.ml:149:36>>*/ return Stdlib_Array[20].call
+             (null,
               function(b, accu$1){
                var i$0 =  /*<<weak.ml:149:21>>*/ i, accu = accu$1;
                for(;;){
@@ -25993,8 +25786,8 @@
     }
     function iter(f, t){
      var i =  /*<<weak.ml:159:15>>*/ 0;
-      /*<<weak.ml:159:30>>*/ return caml_call2
-             (Stdlib_Array[12],
+      /*<<weak.ml:159:30>>*/ return Stdlib_Array[12].call
+             (null,
               function(b){
                var i$0 =  /*<<weak.ml:159:15>>*/ i;
                for(;;){
@@ -26015,8 +25808,8 @@
     }
     function iter_weak(f, t){
      var i =  /*<<weak.ml:169:16>>*/ 0;
-      /*<<weak.ml:169:31>>*/ return caml_call2
-             (Stdlib_Array[13],
+      /*<<weak.ml:169:31>>*/ return Stdlib_Array[13].call
+             (null,
               function(j, b){
                var i$0 =  /*<<weak.ml:169:16>>*/ i;
                for(;;){
@@ -26051,8 +25844,8 @@
      /*<<weak.ml:174:62>>*/ }
     function count(t){
      var _s_ =  /*<<weak.ml:178:21>>*/ 0;
-      /*<<weak.ml:178:37>>*/ return caml_call3
-             (Stdlib_Array[20],
+      /*<<weak.ml:178:37>>*/ return Stdlib_Array[20].call
+             (null,
               function(_t_, _u_){
                 /*<<weak.ml:178:21>>*/ return count_bucket(_s_, _t_, _u_);
               },
@@ -26063,8 +25856,8 @@
      var
       oldlen =  /*<<weak.ml:217:4>>*/ t[1].length - 1,
       newlen =
-         /*<<weak.ml:181:18>>*/ caml_call2
-         (Stdlib_Int[10], ((3 * oldlen | 0) / 2 | 0) + 3 | 0, Stdlib_Sys[13]);
+         /*<<weak.ml:181:18>>*/ Stdlib_Int[10].call
+         (null, ((3 * oldlen | 0) / 2 | 0) + 3 | 0, Stdlib_Sys[13]);
       /*<<weak.ml:219:4>>*/ if(oldlen < newlen){
       var
        newt =  /*<<weak.ml:220:17>>*/ create$0(newlen),
@@ -26106,19 +25899,17 @@
        if(sz <= i$2){
         var
          newsz =
-            /*<<weak.ml:244:10>>*/ caml_call2
-            (Stdlib_Int[10],
-             ((3 * sz | 0) / 2 | 0) + 3 | 0,
-             Stdlib_Sys[13] - 2 | 0);
+            /*<<weak.ml:244:10>>*/ Stdlib_Int[10].call
+            (null, ((3 * sz | 0) / 2 | 0) + 3 | 0, Stdlib_Sys[13] - 2 | 0);
          /*<<weak.ml:246:8>>*/ if(newsz <= sz)
-          /*<<weak.ml:246:28>>*/ caml_call1
-          (Stdlib[2], cst_Weak_Make_hash_bucket_cann);
+          /*<<weak.ml:246:28>>*/ Stdlib[2].call
+          (null, cst_Weak_Make_hash_bucket_cann);
         var
          newbucket$0 =  /*<<weak.ml:247:24>>*/ create(newsz),
          newhashes =  /*<<weak.ml:248:24>>*/ caml_array_make(newsz, 0);
          /*<<weak.ml:249:8>>*/ blit(bucket, 0, newbucket$0, 0, sz);
-         /*<<weak.ml:250:8>>*/ caml_call5
-         (Stdlib_Array[9], hashes, 0, newhashes, 0, sz);
+         /*<<weak.ml:250:8>>*/ Stdlib_Array[9].call
+         (null, hashes, 0, newhashes, 0, sz);
          /*<<weak.ml:251:8>>*/ caml_call3(setter, newbucket$0, sz, d);
          /*<<weak.ml:252:8>>*/ caml_check_bound(newhashes, sz)[sz + 1] = h;
          /*<<weak.ml:253:8>>*/ caml_check_bound(t[1], index)[index + 1] = newbucket$0;
@@ -26177,8 +25968,8 @@
              /*<<weak.ml:208:8>>*/ caml_check_bound(t[1], _k_)[_k_ + 1] = newbucket;
             var
              _q_ =
-                /*<<weak.ml:209:30>>*/ caml_call3
-                (Stdlib_Array[6], hbucket, 0, prev_len),
+                /*<<weak.ml:209:30>>*/ Stdlib_Array[6].call
+                (null, hbucket, 0, prev_len),
              _l_ =  /*<<weak.ml:209:58>>*/ t[5];
              /*<<weak.ml:209:8>>*/ caml_check_bound(t[2], _l_)[_l_ + 1] = _q_;
            }
@@ -26331,17 +26122,13 @@
     function stats(t){
      var
       len =  /*<<weak.ml:326:4>>*/ t[1].length - 1,
-      lens =
-         /*<<weak.ml:327:15>>*/ caml_call2(Stdlib_Array[14], length, t[1]);
-      /*<<weak.ml:328:4>>*/ caml_call2
-      (Stdlib_Array[35], runtime.caml_int_compare, lens);
+      lens =  /*<<weak.ml:327:15>>*/ Stdlib_Array[14].call(null, length, t[1]);
+      /*<<weak.ml:328:4>>*/ Stdlib_Array[35].call
+      (null, runtime.caml_int_compare, lens);
      var
       totlen =
-         /*<<weak.ml:329:17>>*/ caml_call3
-         (Stdlib_Array[18],
-          function(_f_, _e_){ /*<<?>>*/ return _f_ + _e_ | 0;},
-          0,
-          lens),
+         /*<<weak.ml:329:17>>*/ Stdlib_Array[18].call
+         (null, function(_f_, _e_){ /*<<?>>*/ return _f_ + _e_ | 0;}, 0, lens),
       _a_ =  /*<<weak.ml:330:4>>*/ len - 1 | 0,
       _b_ =  /*<<weak.ml:330:63>>*/ len / 2 | 0,
       _c_ =  /*<<weak.ml:330:51>>*/ caml_check_bound(lens, _a_)[_a_ + 1],
@@ -26408,11 +26195,6 @@
             ? 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
     dummy = 0,
     global_data = runtime.caml_get_global_data(),
@@ -26453,8 +26235,8 @@
       [248, "Stdlib.Format.String_tag", runtime.caml_fresh_oo_id(0)];
    function pp_enqueue(state, token){
      /*<<format.ml:220:2>>*/ state[13] = state[13] + token[3] | 0;
-     /*<<format.ml:221:2>>*/ return caml_call2
-            (Stdlib_Queue[3], token, state[28]) /*<<format.ml:221:32>>*/ ;
+     /*<<format.ml:221:2>>*/ return Stdlib_Queue[3].call
+            (null, token, state[28]) /*<<format.ml:221:32>>*/ ;
    }
    var
     pp_infinity =  /*<<?>>*/ 1000000010,
@@ -26477,11 +26259,11 @@
      /*<<format.ml:262:29>>*/ state[11] = 0;
     /*<<format.ml:263:31>>*/ }
    function format_string(state, s){
-    var _U_ =  /*<<format.ml:273:5>>*/ s !== cst$16 ? 1 : 0;
-     /*<<format.ml:273:12>>*/ return _U_
+    var _ah_ =  /*<<format.ml:273:5>>*/ s !== cst$16 ? 1 : 0;
+     /*<<format.ml:273:12>>*/ return _ah_
             ?  /*<<format.ml:273:18>>*/ format_pp_text
               (state, caml_ml_string_length(s), s)
-            : _U_ /*<<format.ml:273:58>>*/ ;
+            : _ah_ /*<<format.ml:273:58>>*/ ;
    }
    function break_new_line(state, param, width){
     var
@@ -26494,7 +26276,7 @@
     var
      indent =  /*<<format.ml:280:2>>*/ (state[6] - width | 0) + offset | 0,
      real_indent =
-        /*<<format.ml:282:20>>*/ caml_call2(Stdlib_Int[10], state[8], indent);
+        /*<<format.ml:282:20>>*/ Stdlib_Int[10].call(null, state[8], indent);
      /*<<format.ml:283:2>>*/ state[10] = real_indent;
      /*<<format.ml:284:2>>*/ state[9] = state[6] - state[10] | 0;
     var n =  /*<<format.ml:285:2>>*/ state[10];
@@ -26517,7 +26299,7 @@
        case 0:
         var
          match$3 =
-            /*<<format.ml:357:16>>*/ caml_call1(Stdlib_Stack[8], state[3]);
+            /*<<format.ml:357:16>>*/ Stdlib_Stack[8].call(null, state[3]);
          /*<<format.ml:357:49>>*/ if(! match$3)
           /*<<format.ml:358:14>>*/ return;
         var
@@ -26535,29 +26317,29 @@
          add_tab(state[6] - state[9] | 0, tabs[1]);
          /*<<format.ml:363:67>>*/ return;
        case 1:
-         /*<<format.ml:348:4>>*/ caml_call1(Stdlib_Stack[5], state[2]);
+         /*<<format.ml:348:4>>*/ Stdlib_Stack[5].call(null, state[2]);
          /*<<format.ml:348:39>>*/ return;
        case 2:
-         /*<<format.ml:354:4>>*/ caml_call1(Stdlib_Stack[5], state[3]);
+         /*<<format.ml:354:4>>*/ Stdlib_Stack[5].call(null, state[3]);
          /*<<format.ml:354:37>>*/ return;
        case 3:
         var
          match$4 =
-            /*<<format.ml:387:16>>*/ caml_call1(Stdlib_Stack[8], state[2]);
+            /*<<format.ml:387:16>>*/ Stdlib_Stack[8].call(null, state[2]);
          /*<<format.ml:387:51>>*/ if(! match$4)
           /*<<format.ml:388:14>>*/ return pp_output_newline(state) /*<<format.ml:433:8>>*/ ;
         var width$0 =  /*<<format.ml:387:51>>*/ match$4[1][2];
          /*<<format.ml:290:29>>*/ return break_new_line(state, _a_, width$0) /*<<format.ml:433:8>>*/ ;
        case 4:
         var
-         _U_ =
+         _ah_ =
             /*<<format.ml:393:4>>*/ state[10] !== (state[6] - state[9] | 0)
             ? 1
             : 0;
-        if(! _U_) return _U_;
+        if(! _ah_) return _ah_;
         var
          match$1 =
-            /*<<format.ml:315:8>>*/ caml_call1(Stdlib_Queue[6], state[28]);
+            /*<<format.ml:315:8>>*/ Stdlib_Queue[6].call(null, state[28]);
          /*<<format.ml:315:37>>*/ if(! match$1)
           /*<<format.ml:316:12>>*/ return;
         var
@@ -26570,7 +26352,7 @@
        default:
         var
          match$5 =
-            /*<<format.ml:428:17>>*/ caml_call1(Stdlib_Stack[5], state[5]);
+            /*<<format.ml:428:17>>*/ Stdlib_Stack[5].call(null, state[5]);
          /*<<format.ml:428:50>>*/ if(! match$5)
           /*<<format.ml:429:15>>*/ return;
         var
@@ -26598,7 +26380,7 @@
         off =  /*<<format.ml:397:4>>*/ breaks[2],
         before = breaks[1],
         match$6 =
-           /*<<format.ml:398:16>>*/ caml_call1(Stdlib_Stack[8], state[2]);
+           /*<<format.ml:398:16>>*/ Stdlib_Stack[8].call(null, state[2]);
         /*<<format.ml:398:51>>*/ if(! match$6)
          /*<<format.ml:399:14>>*/ return;
        var
@@ -26650,7 +26432,7 @@
         n = param[1],
         insertion_point =  /*<<format.ml:367:4>>*/ state[6] - state[9] | 0,
         match$8 =
-           /*<<format.ml:368:16>>*/ caml_call1(Stdlib_Stack[8], state[3]);
+           /*<<format.ml:368:16>>*/ Stdlib_Stack[8].call(null, state[3]);
         /*<<format.ml:368:49>>*/ if(! match$8)
          /*<<format.ml:369:14>>*/ return;
        var
@@ -26680,8 +26462,7 @@
         insertion_point$0 =  /*<<format.ml:335:4>>*/ state[6] - state[9] | 0;
         /*<<format.ml:336:4>>*/ if(state[8] < insertion_point$0){
         var
-         match =
-            /*<<format.ml:304:8>>*/ caml_call1(Stdlib_Stack[8], state[2]);
+         match =  /*<<format.ml:304:8>>*/ Stdlib_Stack[8].call(null, state[2]);
          /*<<format.ml:304:43>>*/ if(match){
          var match$0 = match[1], width = match$0[2], box_type = match$0[1];
           /*<<format.ml:307:4>>*/ if
@@ -26695,25 +26476,25 @@
         width$2 =  /*<<format.ml:339:4>>*/ state[9] - off$1 | 0,
         box_type$1 =
            /*<<format.ml:340:4>>*/ 1 === ty ? 1 : state[9] < size$0 ? ty : 5;
-        /*<<format.ml:345:4>>*/ return caml_call2
-               (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]) /*<<format.ml:433:8>>*/ ;
+        /*<<format.ml:345:4>>*/ return Stdlib_Stack[3].call
+               (null, [0, box_type$1, width$2], state[2]) /*<<format.ml:433:8>>*/ ;
       case 5:
        var tbox =  /*<<format.ml:329:20>>*/ param[1];
-        /*<<format.ml:351:4>>*/ return caml_call2
-               (Stdlib_Stack[3], tbox, state[3]) /*<<format.ml:433:8>>*/ ;
+        /*<<format.ml:351:4>>*/ return Stdlib_Stack[3].call
+               (null, tbox, state[3]) /*<<format.ml:433:8>>*/ ;
       default:
        var
         tag_name$0 =  /*<<format.ml:329:20>>*/ param[1],
         marker$0 =  /*<<format.ml:423:18>>*/ caml_call1(state[24], tag_name$0);
         /*<<format.ml:424:5>>*/ pp_output_string(state, marker$0);
-        /*<<format.ml:424:34>>*/ return caml_call2
-               (Stdlib_Stack[3], tag_name$0, state[5]) /*<<format.ml:433:8>>*/ ;
+        /*<<format.ml:424:34>>*/ return Stdlib_Stack[3].call
+               (null, tag_name$0, state[5]) /*<<format.ml:433:8>>*/ ;
     }
    }
    function advance_left(state){
      /*<<format.ml:440:2>>*/ for(;;){
      var
-      match =  /*<<format.ml:440:8>>*/ caml_call1(Stdlib_Queue[9], state[28]);
+      match =  /*<<format.ml:440:8>>*/ Stdlib_Queue[9].call(null, state[28]);
       /*<<format.ml:440:37>>*/ if(! match)  /*<<format.ml:441:12>>*/ return 0;
      var
       match$0 =  /*<<format.ml:440:37>>*/ match[1],
@@ -26721,11 +26502,11 @@
       length = match$0[3],
       token = match$0[2],
       pending_count =  /*<<format.ml:443:4>>*/ state[13] - state[12] | 0,
-      _U_ =  /*<<format.ml:42:19>>*/ 0 <= size ? 1 : 0,
-      _T_ =
-         /*<<format.ml:444:25>>*/ _U_ || (state[9] <= pending_count ? 1 : 0);
-     if(! _T_) return _T_;
-      /*<<format.ml:445:6>>*/ caml_call1(Stdlib_Queue[5], state[28]);
+      _ah_ =  /*<<format.ml:42:19>>*/ 0 <= size ? 1 : 0,
+      _ag_ =
+         /*<<format.ml:444:25>>*/ _ah_ || (state[9] <= pending_count ? 1 : 0);
+     if(! _ag_) return _ag_;
+      /*<<format.ml:445:6>>*/ Stdlib_Queue[5].call(null, state[28]);
      var size$0 =  /*<<format.ml:446:38>>*/ 0 <= size ? size : pp_infinity;
       /*<<format.ml:447:6>>*/ format_pp_token(state, size$0, token);
       /*<<format.ml:447:38>>*/ state[12] = length + state[12] | 0;
@@ -26740,14 +26521,13 @@
             (state, [0, size, [0, s], size]) /*<<format.ml:459:78>>*/ ;
    }
    function initialize_scan_stack(stack){
-     /*<<format.ml:475:2>>*/ caml_call1(Stdlib_Stack[9], stack);
+     /*<<format.ml:475:2>>*/ Stdlib_Stack[9].call(null, stack);
     var queue_elem =  /*<<format.ml:475:19>>*/ [0, unknown, _b_, 0];
-     /*<<format.ml:477:2>>*/ return caml_call2
-            (Stdlib_Stack[3], [0, -1, queue_elem], stack) /*<<format.ml:477:50>>*/ ;
+     /*<<format.ml:477:2>>*/ return Stdlib_Stack[3].call
+            (null, [0, -1, queue_elem], stack) /*<<format.ml:477:50>>*/ ;
    }
    function set_size(state, ty){
-    var
-     match =  /*<<format.ml:489:8>>*/ caml_call1(Stdlib_Stack[8], state[1]);
+    var match =  /*<<format.ml:489:8>>*/ Stdlib_Stack[8].call(null, state[1]);
      /*<<format.ml:489:41>>*/ if(! match)  /*<<format.ml:490:12>>*/ return;
     var
      match$0 =  /*<<format.ml:489:41>>*/ match[1],
@@ -26763,7 +26543,7 @@
          /*<<format.ml:504:8>>*/ if(1 - ty){
          var x$0 =  /*<<format.ml:504:23>>*/ state[13] + size | 0;
           /*<<format.ml:505:70>>*/ queue_elem[1] = x$0;
-          /*<<format.ml:506:10>>*/ caml_call1(Stdlib_Stack[5], state[1]);
+          /*<<format.ml:506:10>>*/ Stdlib_Stack[5].call(null, state[1]);
         }
          /*<<format.ml:504:8>>*/ return;
        case 2:
@@ -26771,7 +26551,7 @@
          /*<<format.ml:499:8>>*/ if(ty){
          var x =  /*<<format.ml:499:19>>*/ state[13] + size | 0;
           /*<<format.ml:500:70>>*/ queue_elem[1] = x;
-          /*<<format.ml:501:10>>*/ caml_call1(Stdlib_Stack[5], state[1]);
+          /*<<format.ml:501:10>>*/ Stdlib_Stack[5].call(null, state[1]);
         }
          /*<<format.ml:499:8>>*/ return;
      }
@@ -26781,8 +26561,7 @@
      /*<<format.ml:516:24>>*/ if(b)
       /*<<format.ml:517:12>>*/ set_size(state, 1);
     var elem =  /*<<format.ml:518:2>>*/ [0, state[13], token];
-     /*<<format.ml:519:2>>*/ return caml_call2
-            (Stdlib_Stack[3], elem, state[1]) /*<<format.ml:519:37>>*/ ;
+     /*<<format.ml:519:2>>*/ return Stdlib_Stack[3].call(null, elem, state[1]) /*<<format.ml:519:37>>*/ ;
    }
    function pp_open_box_gen(state, indent, br_ty){
      /*<<format.ml:526:2>>*/ state[14] = state[14] + 1 | 0;
@@ -26792,54 +26571,54 @@
       elem =  /*<<format.ml:529:4>>*/ [0, size, [4, indent, br_ty], 0];
       /*<<format.ml:530:4>>*/ return scan_push(state, 0, elem) /*<<format.ml:532:45>>*/ ;
     }
-    var _T_ =  /*<<format.ml:531:2>>*/ state[14] === state[15] ? 1 : 0;
-    if(! _T_) return _T_;
+    var _ag_ =  /*<<format.ml:531:2>>*/ state[14] === state[15] ? 1 : 0;
+    if(! _ag_) return _ag_;
     var
      s =  /*<<format.ml:532:7>>*/ state[16],
      x =  /*<<format.ml:467:2>>*/ caml_ml_string_length(s);
      /*<<format.ml:467:57>>*/ return enqueue_string_as(state, x, s) /*<<format.ml:532:45>>*/ ;
    }
    function pp_close_box(state, param){
-    var _S_ =  /*<<format.ml:540:2>>*/ 1 < state[14] ? 1 : 0;
-    if(_S_){
+    var _af_ =  /*<<format.ml:540:2>>*/ 1 < state[14] ? 1 : 0;
+    if(_af_){
       /*<<format.ml:541:2>>*/ if(state[14] < state[15]){
        /*<<format.ml:544:6>>*/ pp_enqueue(state, [0, zero, 1, 0]);
        /*<<format.ml:545:6>>*/ set_size(state, 1);
        /*<<format.ml:545:27>>*/ set_size(state, 0);
      }
       /*<<format.ml:547:4>>*/ state[14] = state[14] - 1 | 0;
-     var _T_ = 0;
+     var _ag_ = 0;
     }
     else
-     var _T_ =  /*<<format.ml:540:2>>*/ _S_;
-    return _T_;
+     var _ag_ =  /*<<format.ml:540:2>>*/ _af_;
+    return _ag_;
     /*<<format.ml:548:5>>*/ }
    function pp_open_stag(state, tag_name){
      /*<<format.ml:553:2>>*/ if(state[22]){
-      /*<<format.ml:555:4>>*/ caml_call2(Stdlib_Stack[3], tag_name, state[4]);
+      /*<<format.ml:555:4>>*/ Stdlib_Stack[3].call(null, tag_name, state[4]);
       /*<<format.ml:556:4>>*/ caml_call1(state[26], tag_name);
     }
-    var _S_ =  /*<<format.ml:558:2>>*/ state[23];
-    if(! _S_) return _S_;
+    var _af_ =  /*<<format.ml:558:2>>*/ state[23];
+    if(! _af_) return _af_;
     var token =  /*<<format.ml:559:4>>*/ [6, tag_name];
      /*<<format.ml:560:4>>*/ return pp_enqueue(state, [0, zero, token, 0]) /*<<format.ml:560:60>>*/ ;
    }
    function pp_close_stag(state, param){
      /*<<format.ml:565:2>>*/ if(state[23])
       /*<<format.ml:566:4>>*/ pp_enqueue(state, [0, zero, 5, 0]);
-    var _R_ =  /*<<format.ml:567:2>>*/ state[22];
-    if(_R_){
+    var _ae_ =  /*<<format.ml:567:2>>*/ state[22];
+    if(_ae_){
      var
-      match =  /*<<format.ml:568:10>>*/ caml_call1(Stdlib_Stack[5], state[4]);
+      match =  /*<<format.ml:568:10>>*/ Stdlib_Stack[5].call(null, state[4]);
       /*<<format.ml:568:42>>*/ if(match){
       var tag_name = match[1];
        /*<<format.ml:571:6>>*/ return caml_call1(state[27], tag_name) /*<<format.ml:571:39>>*/ ;
      }
-     var _S_ =  /*<<format.ml:569:14>>*/ 0;
+     var _af_ =  /*<<format.ml:569:14>>*/ 0;
     }
     else
-     var _S_ =  /*<<format.ml:567:2>>*/ _R_;
-    return _S_;
+     var _af_ =  /*<<format.ml:567:2>>*/ _ae_;
+    return _af_;
     /*<<format.ml:571:39>>*/ }
    function pp_set_print_tags(state, b){
      /*<<format.ml:573:32>>*/ state[22] = b;
@@ -26881,20 +26660,20 @@
    function pp_rinit(state){
      /*<<format.ml:225:2>>*/ state[12] = 1;
      /*<<format.ml:225:28>>*/ state[13] = 1;
-     /*<<format.ml:226:2>>*/ caml_call1(Stdlib_Queue[12], state[28]);
+     /*<<format.ml:226:2>>*/ Stdlib_Queue[12].call(null, state[28]);
      /*<<format.ml:605:2>>*/ initialize_scan_stack(state[1]);
-     /*<<format.ml:606:2>>*/ caml_call1(Stdlib_Stack[9], state[2]);
-     /*<<format.ml:607:2>>*/ caml_call1(Stdlib_Stack[9], state[3]);
-     /*<<format.ml:608:2>>*/ caml_call1(Stdlib_Stack[9], state[4]);
-     /*<<format.ml:609:2>>*/ caml_call1(Stdlib_Stack[9], state[5]);
+     /*<<format.ml:606:2>>*/ Stdlib_Stack[9].call(null, state[2]);
+     /*<<format.ml:607:2>>*/ Stdlib_Stack[9].call(null, state[3]);
+     /*<<format.ml:608:2>>*/ Stdlib_Stack[9].call(null, state[4]);
+     /*<<format.ml:609:2>>*/ Stdlib_Stack[9].call(null, state[5]);
      /*<<format.ml:609:33>>*/ state[10] = 0;
      /*<<format.ml:611:2>>*/ state[14] = 0;
      /*<<format.ml:612:2>>*/ state[9] = state[6];
      /*<<format.ml:536:28>>*/ return pp_open_box_gen(state, 0, 3) /*<<format.ml:613:23>>*/ ;
    }
    function pp_flush_queue(state, end_with_newline){
-     /*<<format.ml:616:2>>*/ caml_call2
-     (Stdlib_Stack[13],
+     /*<<format.ml:616:2>>*/ Stdlib_Stack[13].call
+     (null,
       function(param){
         /*<<format.ml:616:23>>*/ return pp_close_stag(state, 0) /*<<format.ml:616:45>>*/ ;
       },
@@ -26911,10 +26690,10 @@
     }
     /*<<format.ml:628:16>>*/ }
    function pp_print_as_size(state, size, s){
-    var _R_ =  /*<<format.ml:638:2>>*/ state[14] < state[15] ? 1 : 0;
-    return _R_
+    var _ae_ =  /*<<format.ml:638:2>>*/ state[14] < state[15] ? 1 : 0;
+    return _ae_
             ?  /*<<format.ml:639:7>>*/ enqueue_string_as(state, size, s)
-            : _R_ /*<<format.ml:639:37>>*/ ;
+            : _ae_ /*<<format.ml:639:37>>*/ ;
    }
    function pp_print_as(state, isize, s){
      /*<<format.ml:643:44>>*/ return pp_print_as_size(state, isize, s) /*<<format.ml:643:46>>*/ ;
@@ -26924,8 +26703,8 @@
      /*<<format.ml:643:44>>*/ return pp_print_as_size(state, isize, s) /*<<format.ml:647:39>>*/ ;
    }
    function pp_print_substring_as(pos, len, state, size, source){
-    var _R_ =  /*<<format.ml:650:2>>*/ state[14] < state[15] ? 1 : 0;
-    if(! _R_) return _R_;
+    var _ae_ =  /*<<format.ml:650:2>>*/ state[14] < state[15] ? 1 : 0;
+    if(! _ae_) return _ae_;
     var token =  /*<<format.ml:463:2>>*/ [1, source, pos, len];
      /*<<format.ml:464:64>>*/ return enqueue_advance
             (state, [0, size, token, size]) /*<<format.ml:651:64>>*/ ;
@@ -26936,24 +26715,24 @@
    }
    function pp_print_bytes(state, s){
     var
-     s$0 =  /*<<format.ml:657:37>>*/ caml_call1(Stdlib_Bytes[6], s),
+     s$0 =  /*<<format.ml:657:37>>*/ Stdlib_Bytes[6].call(null, s),
      isize =  /*<<format.ml:657:56>>*/ runtime.caml_ml_bytes_length(s);
      /*<<format.ml:643:44>>*/ return pp_print_as_size(state, isize, s$0) /*<<format.ml:657:56>>*/ ;
    }
    function pp_print_int(state, i){
      /*<<format.ml:660:49>>*/ return  /*<<format.ml:660:66>>*/ pp_print_string
-            (state,  /*<<format.ml:660:49>>*/ caml_call1(Stdlib_Int[12], i)) /*<<format.ml:660:66>>*/ ;
+            (state,  /*<<format.ml:660:49>>*/ Stdlib_Int[12].call(null, i)) /*<<format.ml:660:66>>*/ ;
    }
    function pp_print_float(state, f){
      /*<<format.ml:663:51>>*/ return  /*<<format.ml:663:70>>*/ pp_print_string
-            (state,  /*<<format.ml:663:51>>*/ caml_call1(Stdlib[35], f)) /*<<format.ml:663:70>>*/ ;
+            (state,  /*<<format.ml:663:51>>*/ Stdlib[35].call(null, f)) /*<<format.ml:663:70>>*/ ;
    }
    function pp_print_bool(state, b){
      /*<<format.ml:666:50>>*/ return  /*<<format.ml:666:68>>*/ pp_print_string
-            (state,  /*<<format.ml:666:50>>*/ caml_call1(Stdlib[30], b)) /*<<format.ml:666:68>>*/ ;
+            (state,  /*<<format.ml:666:50>>*/ Stdlib[30].call(null, b)) /*<<format.ml:666:68>>*/ ;
    }
    function pp_print_char(state, c){
-    var s =  /*<<format.ml:670:22>>*/ caml_call2(Stdlib_String[1], 1, c);
+    var s =  /*<<format.ml:670:22>>*/ Stdlib_String[1].call(null, 1, c);
      /*<<format.ml:643:44>>*/ return pp_print_as_size(state, 1, s) /*<<format.ml:670:39>>*/ ;
    }
    function pp_print_nothing(state, param){ /*<<format.ml:672:33>>*/ return 0;
@@ -26982,24 +26761,24 @@
      /*<<format.ml:695:46>>*/ return caml_call1(state[18], 0) /*<<format.ml:695:69>>*/ ;
    }
    function pp_force_newline(state, param){
-    var _R_ =  /*<<format.ml:700:2>>*/ state[14] < state[15] ? 1 : 0;
-    return _R_
+    var _ae_ =  /*<<format.ml:700:2>>*/ state[14] < state[15] ? 1 : 0;
+    return _ae_
             ?  /*<<format.ml:701:4>>*/ enqueue_advance(state, [0, zero, 3, 0])
-            : _R_ /*<<format.ml:701:78>>*/ ;
+            : _ae_ /*<<format.ml:701:78>>*/ ;
    }
    function pp_print_if_newline(state, param){
-    var _R_ =  /*<<format.ml:706:2>>*/ state[14] < state[15] ? 1 : 0;
-    return _R_
+    var _ae_ =  /*<<format.ml:706:2>>*/ state[14] < state[15] ? 1 : 0;
+    return _ae_
             ?  /*<<format.ml:707:4>>*/ enqueue_advance(state, [0, zero, 4, 0])
-            : _R_ /*<<format.ml:708:61>>*/ ;
+            : _ae_ /*<<format.ml:708:61>>*/ ;
    }
    function pp_print_custom_break(state, fits, breaks){
     var
      after =  /*<<format.ml:714:2>>*/ fits[3],
      width = fits[2],
      before = fits[1],
-     _R_ =  /*<<format.ml:715:2>>*/ state[14] < state[15] ? 1 : 0;
-    if(! _R_) return _R_;
+     _ae_ =  /*<<format.ml:715:2>>*/ state[14] < state[15] ? 1 : 0;
+    if(! _ae_) return _ae_;
     var
      size =  /*<<format.ml:716:4>>*/ - state[13] | 0,
      token =  /*<<format.ml:717:4>>*/ [2, fits, breaks],
@@ -27022,31 +26801,31 @@
    }
    function pp_open_tbox(state, param){
      /*<<format.ml:742:2>>*/ state[14] = state[14] + 1 | 0;
-    var _R_ =  /*<<format.ml:743:2>>*/ state[14] < state[15] ? 1 : 0;
-    if(! _R_) return _R_;
+    var _ae_ =  /*<<format.ml:743:2>>*/ state[14] < state[15] ? 1 : 0;
+    if(! _ae_) return _ae_;
     var elem =  /*<<format.ml:745:4>>*/ [0, zero, [5, [0, [0, 0]]], 0];
      /*<<format.ml:746:4>>*/ return enqueue_advance(state, elem) /*<<format.ml:746:30>>*/ ;
    }
    function pp_close_tbox(state, param){
-    var _Q_ =  /*<<format.ml:751:2>>*/ 1 < state[14] ? 1 : 0;
-    if(_Q_){
-     var _R_ =  /*<<format.ml:752:2>>*/ state[14] < state[15] ? 1 : 0;
-     if(_R_){
+    var _ad_ =  /*<<format.ml:751:2>>*/ 1 < state[14] ? 1 : 0;
+    if(_ad_){
+     var _ae_ =  /*<<format.ml:752:2>>*/ state[14] < state[15] ? 1 : 0;
+     if(_ae_){
       var elem =  /*<<format.ml:754:5>>*/ [0, zero, 2, 0];
        /*<<format.ml:755:5>>*/ enqueue_advance(state, elem);
        /*<<format.ml:755:31>>*/ state[14] = state[14] - 1 | 0;
-      var _P_ = 0;
+      var _ac_ = 0;
      }
      else
-      var _P_ =  /*<<format.ml:752:2>>*/ _R_;
+      var _ac_ =  /*<<format.ml:752:2>>*/ _ae_;
     }
     else
-     var _P_ =  /*<<format.ml:751:2>>*/ _Q_;
-    return _P_;
+     var _ac_ =  /*<<format.ml:751:2>>*/ _ad_;
+    return _ac_;
     /*<<format.ml:757:5>>*/ }
    function pp_print_tbreak(state, width, offset){
-    var _P_ =  /*<<format.ml:762:2>>*/ state[14] < state[15] ? 1 : 0;
-    if(! _P_) return _P_;
+    var _ac_ =  /*<<format.ml:762:2>>*/ state[14] < state[15] ? 1 : 0;
+    if(! _ac_) return _ac_;
     var
      size =  /*<<format.ml:763:4>>*/ - state[13] | 0,
      elem =  /*<<format.ml:764:4>>*/ [0, size, [3, width, offset], width];
@@ -27056,16 +26835,16 @@
      /*<<format.ml:768:28>>*/ return pp_print_tbreak(state, 0, 0) /*<<format.ml:768:53>>*/ ;
    }
    function pp_set_tab(state, param){
-    var _P_ =  /*<<format.ml:771:2>>*/ state[14] < state[15] ? 1 : 0;
-    if(! _P_) return _P_;
+    var _ac_ =  /*<<format.ml:771:2>>*/ state[14] < state[15] ? 1 : 0;
+    if(! _ac_) return _ac_;
     var elem =  /*<<format.ml:772:4>>*/ [0, zero, 0, 0];
      /*<<format.ml:773:4>>*/ return enqueue_advance(state, elem) /*<<format.ml:773:30>>*/ ;
    }
    function pp_set_max_boxes(state, n){
     var
-     _O_ =  /*<<format.ml:783:31>>*/ 1 < n ? 1 : 0,
-     _P_ = _O_ ? (state[15] = n, 0) : _O_;
-    return _P_;
+     _ab_ =  /*<<format.ml:783:31>>*/ 1 < n ? 1 : 0,
+     _ac_ = _ab_ ? (state[15] = n, 0) : _ab_;
+    return _ac_;
     /*<<format.ml:783:68>>*/ }
    function pp_get_max_boxes(state, param){
      /*<<format.ml:786:32>>*/ return state[15];
@@ -27084,12 +26863,12 @@
      /*<<format.ml:797:2>>*/ return n < 1000000010 ? n : 1000000009 /*<<format.ml:797:49>>*/ ;
    }
    function pp_set_max_indent(state, n$0){
-    var _O_ =  /*<<format.ml:813:2>>*/ 1 < n$0 ? 1 : 0;
-    if(! _O_) return _O_;
+    var _ab_ =  /*<<format.ml:813:2>>*/ 1 < n$0 ? 1 : 0;
+    if(! _ab_) return _ab_;
     var
      n$1 =  /*<<format.ml:814:4>>*/ state[6] - n$0 | 0,
-     _N_ =  /*<<format.ml:802:2>>*/ 1 <= n$1 ? 1 : 0;
-    if(! _N_) return _N_;
+     _aa_ =  /*<<format.ml:802:2>>*/ 1 <= n$1 ? 1 : 0;
+    if(! _aa_) return _aa_;
     var n =  /*<<format.ml:803:12>>*/ pp_limit(n$1);
      /*<<format.ml:804:4>>*/ state[7] = n;
      /*<<format.ml:805:4>>*/ state[8] = state[6] - state[7] | 0;
@@ -27099,20 +26878,20 @@
      /*<<format.ml:817:33>>*/ return state[8];
     /*<<format.ml:817:52>>*/ }
    function pp_set_margin(state, n){
-    var _M_ =  /*<<format.ml:820:2>>*/ 1 <= n ? 1 : 0;
-    if(! _M_) return _M_;
+    var _$_ =  /*<<format.ml:820:2>>*/ 1 <= n ? 1 : 0;
+    if(! _$_) return _$_;
     var n$0 =  /*<<format.ml:821:12>>*/ pp_limit(n);
      /*<<format.ml:822:4>>*/ state[6] = n$0;
      /*<<format.ml:823:4>>*/ if(state[8] <= state[6])
      var new_max_indent =  /*<<format.ml:826:11>>*/ state[8];
     else
      var
-      _N_ =
-         /*<<format.ml:830:15>>*/ caml_call2
-         (Stdlib_Int[11], state[6] - state[7] | 0, state[6] / 2 | 0),
+      _aa_ =
+         /*<<format.ml:830:15>>*/ Stdlib_Int[11].call
+         (null, state[6] - state[7] | 0, state[6] / 2 | 0),
       new_max_indent =
-         /*<<format.ml:831:40>>*/  /*<<format.ml:830:7>>*/ caml_call2
-         (Stdlib_Int[11], _N_, 1);
+         /*<<format.ml:831:40>>*/  /*<<format.ml:830:7>>*/ Stdlib_Int[11].call
+         (null, _aa_, 1);
      /*<<format.ml:833:4>>*/ return pp_set_max_indent(state, new_max_indent) /*<<format.ml:833:42>>*/ ;
    }
    function validate_geometry(param){
@@ -27143,11 +26922,11 @@
       /*<<format.ml:866:4>>*/ return pp_set_full_geometry(state, geometry) /*<<format.ml:866:39>>*/ ;
     var
      msg =  /*<<format.ml:862:34>>*/ match[1],
-     _M_ =
-        /*<<format.ml:864:28>>*/ caml_call2
-        (Stdlib[28], cst_Format_pp_set_geometry, msg);
+     _$_ =
+        /*<<format.ml:864:28>>*/ Stdlib[28].call
+        (null, cst_Format_pp_set_geometry, msg);
      /*<<format.ml:864:62>>*/ throw caml_maybe_attach_backtrace
-           ([0, Stdlib[6], _M_], 1);
+           ([0, Stdlib[6], _$_], 1);
     /*<<format.ml:866:39>>*/ }
    function pp_safe_set_geometry(state, max_indent, margin){
     var geometry =  /*<<format.ml:869:2>>*/ [0, max_indent, margin];
@@ -27197,14 +26976,13 @@
      /*<<format.ml:915:31>>*/ return caml_call3(state[17], cst$7, 0, 1) /*<<format.ml:915:60>>*/ ;
    }
    var
-    blank_line =
-       /*<<format.ml:918:17>>*/ caml_call2(Stdlib_String[1], 80, 32),
+    blank_line =  /*<<format.ml:918:17>>*/ Stdlib_String[1].call(null, 80, 32),
     _g_ =  /*<<format.ml:918:35>>*/ [4, 0, 3];
    function display_blanks(state, n$1){
     var n =  /*<<format.ml:920:2>>*/ n$1;
     for(;;){
-     var _M_ = 0 < n ? 1 : 0;
-     if(! _M_) return _M_;
+     var _$_ = 0 < n ? 1 : 0;
+     if(! _$_) return _$_;
       /*<<format.ml:921:2>>*/ if(80 >= n)
        /*<<format.ml:921:18>>*/ return caml_call3(state[17], blank_line, 0, n) /*<<format.ml:925:5>>*/ ;
       /*<<format.ml:923:4>>*/ caml_call3(state[17], blank_line, 0, 80);
@@ -27213,22 +26991,26 @@
     }
     /*<<format.ml:925:5>>*/ }
    function pp_set_formatter_out_channel(state, oc){
-     /*<<format.ml:934:25>>*/ state[17] = caml_call1(Stdlib[69], oc);
+    var _Y_ =  /*<<format.ml:934:25>>*/ Stdlib[69];
+     /*<<format.ml:934:44>>*/ state[17] =
+     function(_Z_, ___, _$_){
+       /*<<format.ml:934:25>>*/ return _Y_(oc, _Z_, ___, _$_);
+     };
      /*<<format.ml:935:2>>*/ state[18] =
      function(param){
-       /*<<format.ml:935:35>>*/ return caml_call1(Stdlib[63], oc) /*<<format.ml:935:43>>*/ ;
+       /*<<format.ml:935:35>>*/ return Stdlib[63].call(null, oc) /*<<format.ml:935:43>>*/ ;
      };
      /*<<format.ml:936:47>>*/ state[19] =
-     function(_M_){
-       /*<<format.ml:936:26>>*/ return display_newline(state, _M_);
+     function(_Y_){
+       /*<<format.ml:936:26>>*/ return display_newline(state, _Y_);
      };
      /*<<format.ml:937:45>>*/ state[20] =
-     function(_M_){
-       /*<<format.ml:937:25>>*/ return display_blanks(state, _M_);
+     function(_Y_){
+       /*<<format.ml:937:25>>*/ return display_blanks(state, _Y_);
      };
      /*<<format.ml:938:45>>*/ state[21] =
-     function(_M_){
-       /*<<format.ml:938:25>>*/ return display_blanks(state, _M_);
+     function(_Y_){
+       /*<<format.ml:938:25>>*/ return display_blanks(state, _Y_);
      };
      /*<<format.ml:938:45>>*/ return 0;
    }
@@ -27237,40 +27019,40 @@
     if(tag !== String_tag)  /*<<format.ml:948:9>>*/ return cst$10;
     var
      s =  /*<<format.ml:946:31>>*/ param[2],
-     _M_ =  /*<<format.ml:947:26>>*/ caml_call2(Stdlib[28], s, cst$8);
-     /*<<format.ml:947:33>>*/ return caml_call2(Stdlib[28], cst$9, _M_) /*<<format.ml:948:11>>*/ ;
+     _Y_ =  /*<<format.ml:947:26>>*/ Stdlib[28].call(null, s, cst$8);
+     /*<<format.ml:947:33>>*/ return Stdlib[28].call(null, cst$9, _Y_) /*<<format.ml:948:11>>*/ ;
    }
    function default_pp_mark_close_tag(param){
     var tag =  /*<<format.ml:949:32>>*/ param[1];
     if(tag !== String_tag)  /*<<format.ml:951:9>>*/ return cst$13;
     var
      s =  /*<<format.ml:949:32>>*/ param[2],
-     _M_ =  /*<<format.ml:950:27>>*/ caml_call2(Stdlib[28], s, cst$11);
-     /*<<format.ml:950:34>>*/ return caml_call2(Stdlib[28], cst$12, _M_) /*<<format.ml:951:11>>*/ ;
+     _Y_ =  /*<<format.ml:950:27>>*/ Stdlib[28].call(null, s, cst$11);
+     /*<<format.ml:950:34>>*/ return Stdlib[28].call(null, cst$12, _Y_) /*<<format.ml:951:11>>*/ ;
    }
-   function default_pp_print_open_tag(_M_){ /*<<?>>*/ return 0;}
-   function default_pp_print_close_tag(_M_){return 0;}
+   function default_pp_print_open_tag(_Y_){ /*<<?>>*/ return 0;}
+   function default_pp_print_close_tag(_Y_){return 0;}
    function pp_make_formatter(f, g, h, i, j){
     var
-     pp_queue =  /*<<format.ml:960:17>>*/ caml_call1(Stdlib_Queue[2], 0),
+     pp_queue =  /*<<format.ml:960:17>>*/ Stdlib_Queue[2].call(null, 0),
      sys_tok =  /*<<format.ml:961:2>>*/ [0, unknown, _g_, 0];
-     /*<<format.ml:963:2>>*/ caml_call2(Stdlib_Queue[3], sys_tok, pp_queue);
-    var scan_stack =  /*<<format.ml:964:19>>*/ caml_call1(Stdlib_Stack[2], 0);
+     /*<<format.ml:963:2>>*/ Stdlib_Queue[3].call(null, sys_tok, pp_queue);
+    var scan_stack =  /*<<format.ml:964:19>>*/ Stdlib_Stack[2].call(null, 0);
      /*<<format.ml:965:2>>*/ initialize_scan_stack(scan_stack);
-     /*<<format.ml:966:2>>*/ caml_call2
-     (Stdlib_Stack[3], [0, 1, sys_tok], scan_stack);
+     /*<<format.ml:966:2>>*/ Stdlib_Stack[3].call
+     (null, [0, 1, sys_tok], scan_stack);
     var
      pp_margin =  /*<<format.ml:966:64>>*/ 78,
-     _J_ =  /*<<format.ml:974:20>>*/ Stdlib[19],
-     _K_ = caml_call1(Stdlib_Stack[2], 0),
-     _L_ =  /*<<format.ml:973:19>>*/ caml_call1(Stdlib_Stack[2], 0),
-     _M_ =  /*<<format.ml:972:20>>*/ caml_call1(Stdlib_Stack[2], 0);
+     _V_ =  /*<<format.ml:974:20>>*/ Stdlib[19],
+     _W_ = Stdlib_Stack[2].call(null, 0),
+     _X_ =  /*<<format.ml:973:19>>*/ Stdlib_Stack[2].call(null, 0),
+     _Y_ =  /*<<format.ml:972:20>>*/ Stdlib_Stack[2].call(null, 0);
      /*<<format.ml:971:22>>*/ return [0,
             scan_stack,
-            caml_call1(Stdlib_Stack[2], 0),
-            _M_,
-            _L_,
-            _K_,
+            Stdlib_Stack[2].call(null, 0),
+            _Y_,
+            _X_,
+            _W_,
             pp_margin,
             10,
             68,
@@ -27280,7 +27062,7 @@
             1,
             1,
             1,
-            _J_,
+            _V_,
             cst$14,
             f,
             g,
@@ -27305,39 +27087,45 @@
         /*<<format.ml:1014:12>>*/ pp_make_formatter
         (output,
          flush,
-         function(_J_){ /*<<?>>*/ return 0;},
-         function(_J_){return 0;},
-         function(_J_){return 0;});
+         function(_V_){ /*<<?>>*/ return 0;},
+         function(_V_){return 0;},
+         function(_V_){return 0;});
      /*<<format.ml:1015:43>>*/ ppf[19] =
-     function(_J_){
-       /*<<format.ml:1015:24>>*/ return display_newline(ppf, _J_);
+     function(_V_){
+       /*<<format.ml:1015:24>>*/ return display_newline(ppf, _V_);
      };
      /*<<format.ml:1016:41>>*/ ppf[20] =
-     function(_J_){
-       /*<<format.ml:1016:23>>*/ return display_blanks(ppf, _J_);
+     function(_V_){
+       /*<<format.ml:1016:23>>*/ return display_blanks(ppf, _V_);
      };
      /*<<format.ml:1017:41>>*/ ppf[21] =
-     function(_J_){
-       /*<<format.ml:1017:23>>*/ return display_blanks(ppf, _J_);
+     function(_V_){
+       /*<<format.ml:1017:23>>*/ return display_blanks(ppf, _V_);
      };
      /*<<format.ml:1018:2>>*/ return ppf;
     /*<<format.ml:1018:5>>*/ }
    function formatter_of_out_channel(oc){
-     /*<<format.ml:1023:17>>*/ return  /*<<format.ml:1023:38>>*/ make_formatter
-            ( /*<<format.ml:1023:17>>*/ caml_call1(Stdlib[69], oc),
+    var _S_ =  /*<<format.ml:1023:17>>*/ Stdlib[69];
+     /*<<format.ml:1023:38>>*/ return make_formatter
+            (function(_T_, _U_, _V_){
+               /*<<format.ml:1023:17>>*/ return _S_(oc, _T_, _U_, _V_);
+             },
              function(param){
-               /*<<format.ml:1023:50>>*/ return caml_call1(Stdlib[63], oc) /*<<format.ml:1023:58>>*/ ;
+               /*<<format.ml:1023:50>>*/ return Stdlib[63].call(null, oc) /*<<format.ml:1023:58>>*/ ;
              }) /*<<format.ml:1023:59>>*/ ;
    }
    function formatter_of_buffer(b){
-     /*<<format.ml:1028:17>>*/ return  /*<<format.ml:1028:41>>*/ make_formatter
-            ( /*<<format.ml:1028:17>>*/ caml_call1(Stdlib_Buffer[18], b),
-             function(_J_){ /*<<?>>*/ return 0;}) /*<<format.ml:1028:48>>*/ ;
+    var _P_ =  /*<<format.ml:1028:17>>*/ Stdlib_Buffer[18];
+     /*<<format.ml:1028:41>>*/ return make_formatter
+            (function(_Q_, _R_, _S_){
+               /*<<format.ml:1028:17>>*/ return _P_(b, _Q_, _R_, _S_);
+             },
+             function(_P_){ /*<<?>>*/ return 0;}) /*<<format.ml:1028:48>>*/ ;
    }
    var pp_buffer_size =  /*<<format.ml:918:35>>*/ 512;
    function pp_make_buffer(param){
-     /*<<format.ml:1035:24>>*/ return caml_call1
-            (Stdlib_Buffer[1], pp_buffer_size) /*<<format.ml:1035:52>>*/ ;
+     /*<<format.ml:1035:24>>*/ return Stdlib_Buffer[1].call
+            (null, pp_buffer_size) /*<<format.ml:1035:52>>*/ ;
    }
    var
     stdbuf =  /*<<format.ml:1038:13>>*/ pp_make_buffer(0),
@@ -27365,18 +27153,18 @@
     (Stdlib_Domain[11][3], str_formatter_key, str_formatter);
    function buffered_out_string(key, str, ofs, len){
     var
-     _J_ =  /*<<format.ml:1057:23>>*/ caml_call1(Stdlib_Domain[11][2], key);
-     /*<<format.ml:1057:43>>*/ return caml_call4
-            (Stdlib_Buffer[18], _J_, str, ofs, len) /*<<format.ml:1057:55>>*/ ;
+     _P_ =  /*<<format.ml:1057:23>>*/ caml_call1(Stdlib_Domain[11][2], key);
+     /*<<format.ml:1057:43>>*/ return Stdlib_Buffer[18].call
+            (null, _P_, str, ofs, len) /*<<format.ml:1057:55>>*/ ;
    }
    function buffered_out_flush(oc, key, param){
     var
      buf =  /*<<format.ml:1060:12>>*/ caml_call1(Stdlib_Domain[11][2], key),
-     len =  /*<<format.ml:1061:12>>*/ caml_call1(Stdlib_Buffer[7], buf),
-     str =  /*<<format.ml:1062:12>>*/ caml_call1(Stdlib_Buffer[2], buf);
-     /*<<format.ml:1063:2>>*/ caml_call4(Stdlib[69], oc, str, 0, len);
-     /*<<format.ml:1064:2>>*/ caml_call1(Stdlib[63], oc);
-     /*<<format.ml:1064:17>>*/ return caml_call1(Stdlib_Buffer[8], buf) /*<<format.ml:1065:18>>*/ ;
+     len =  /*<<format.ml:1061:12>>*/ Stdlib_Buffer[7].call(null, buf),
+     str =  /*<<format.ml:1062:12>>*/ Stdlib_Buffer[2].call(null, buf);
+     /*<<format.ml:1063:2>>*/ Stdlib[69].call(null, oc, str, 0, len);
+     /*<<format.ml:1064:2>>*/ Stdlib[63].call(null, oc);
+     /*<<format.ml:1064:17>>*/ return Stdlib_Buffer[8].call(null, buf) /*<<format.ml:1065:18>>*/ ;
    }
    var
     std_buf_key =
@@ -27384,16 +27172,16 @@
        (Stdlib_Domain[11][1],
         0,
         function(param){
-          /*<<format.ml:1067:48>>*/ return caml_call1
-                 (Stdlib_Buffer[1], pp_buffer_size) /*<<format.ml:1067:76>>*/ ;
+          /*<<format.ml:1067:48>>*/ return Stdlib_Buffer[1].call
+                 (null, pp_buffer_size) /*<<format.ml:1067:76>>*/ ;
         }),
     err_buf_key =
        /*<<format.ml:1068:18>>*/ caml_call2
        (Stdlib_Domain[11][1],
         0,
         function(param){
-          /*<<format.ml:1068:48>>*/ return caml_call1
-                 (Stdlib_Buffer[1], pp_buffer_size) /*<<format.ml:1068:76>>*/ ;
+          /*<<format.ml:1068:48>>*/ return Stdlib_Buffer[1].call
+                 (null, pp_buffer_size) /*<<format.ml:1068:76>>*/ ;
         }),
     std_formatter_key =
        /*<<format.ml:1070:24>>*/ caml_call2
@@ -27401,36 +27189,36 @@
         0,
         function(param){
          var
-          _G_ =  /*<<format.ml:1072:22>>*/ Stdlib[39],
+          _M_ =  /*<<format.ml:1072:22>>*/ Stdlib[39],
           ppf =
              /*<<format.ml:1072:4>>*/ pp_make_formatter
-             (function(_H_, _I_, _J_){
+             (function(_N_, _O_, _P_){
                 /*<<format.ml:1072:22>>*/ return buffered_out_string
-                       (std_buf_key, _H_, _I_, _J_);
+                       (std_buf_key, _N_, _O_, _P_);
               },
-              function(_H_){
+              function(_N_){
                 /*<<format.ml:1073:6>>*/ return buffered_out_flush
-                       (_G_, std_buf_key, _H_);
+                       (_M_, std_buf_key, _N_);
               },
-              function(_G_){ /*<<?>>*/ return 0;},
-              function(_G_){return 0;},
-              function(_G_){return 0;});
+              function(_M_){ /*<<?>>*/ return 0;},
+              function(_M_){return 0;},
+              function(_M_){return 0;});
           /*<<format.ml:1075:43>>*/ ppf[19] =
-          function(_G_){
-            /*<<format.ml:1075:24>>*/ return display_newline(ppf, _G_);
+          function(_M_){
+            /*<<format.ml:1075:24>>*/ return display_newline(ppf, _M_);
           };
           /*<<format.ml:1076:41>>*/ ppf[20] =
-          function(_G_){
-            /*<<format.ml:1076:23>>*/ return display_blanks(ppf, _G_);
+          function(_M_){
+            /*<<format.ml:1076:23>>*/ return display_blanks(ppf, _M_);
           };
           /*<<format.ml:1077:41>>*/ ppf[21] =
-          function(_G_){
-            /*<<format.ml:1077:23>>*/ return display_blanks(ppf, _G_);
+          function(_M_){
+            /*<<format.ml:1077:23>>*/ return display_blanks(ppf, _M_);
           };
-          /*<<format.ml:1078:2>>*/ caml_call1
-          (Stdlib_Domain[6],
-           function(_G_){
-             /*<<format.ml:1078:17>>*/ return pp_print_flush(ppf, _G_);
+          /*<<format.ml:1078:2>>*/ Stdlib_Domain[6].call
+          (null,
+           function(_M_){
+             /*<<format.ml:1078:17>>*/ return pp_print_flush(ppf, _M_);
            });
           /*<<format.ml:1078:37>>*/ return ppf;
          /*<<format.ml:1079:5>>*/ });
@@ -27443,36 +27231,36 @@
         0,
         function(param){
          var
-          _D_ =  /*<<format.ml:1084:22>>*/ Stdlib[40],
+          _J_ =  /*<<format.ml:1084:22>>*/ Stdlib[40],
           ppf =
              /*<<format.ml:1084:4>>*/ pp_make_formatter
-             (function(_E_, _F_, _G_){
+             (function(_K_, _L_, _M_){
                 /*<<format.ml:1084:22>>*/ return buffered_out_string
-                       (err_buf_key, _E_, _F_, _G_);
+                       (err_buf_key, _K_, _L_, _M_);
               },
-              function(_E_){
+              function(_K_){
                 /*<<format.ml:1085:6>>*/ return buffered_out_flush
-                       (_D_, err_buf_key, _E_);
+                       (_J_, err_buf_key, _K_);
               },
-              function(_D_){ /*<<?>>*/ return 0;},
-              function(_D_){return 0;},
-              function(_D_){return 0;});
+              function(_J_){ /*<<?>>*/ return 0;},
+              function(_J_){return 0;},
+              function(_J_){return 0;});
           /*<<format.ml:1087:43>>*/ ppf[19] =
-          function(_D_){
-            /*<<format.ml:1087:24>>*/ return display_newline(ppf, _D_);
+          function(_J_){
+            /*<<format.ml:1087:24>>*/ return display_newline(ppf, _J_);
           };
           /*<<format.ml:1088:41>>*/ ppf[20] =
-          function(_D_){
-            /*<<format.ml:1088:23>>*/ return display_blanks(ppf, _D_);
+          function(_J_){
+            /*<<format.ml:1088:23>>*/ return display_blanks(ppf, _J_);
           };
           /*<<format.ml:1089:41>>*/ ppf[21] =
-          function(_D_){
-            /*<<format.ml:1089:23>>*/ return display_blanks(ppf, _D_);
+          function(_J_){
+            /*<<format.ml:1089:23>>*/ return display_blanks(ppf, _J_);
           };
-          /*<<format.ml:1090:2>>*/ caml_call1
-          (Stdlib_Domain[6],
-           function(_D_){
-             /*<<format.ml:1090:17>>*/ return pp_print_flush(ppf, _D_);
+          /*<<format.ml:1090:2>>*/ Stdlib_Domain[6].call
+          (null,
+           function(_J_){
+             /*<<format.ml:1090:17>>*/ return pp_print_flush(ppf, _J_);
            });
           /*<<format.ml:1090:37>>*/ return ppf;
          /*<<format.ml:1091:5>>*/ });
@@ -27496,8 +27284,8 @@
    }
    function flush_buffer_formatter(buf, ppf){
      /*<<format.ml:1104:2>>*/ pp_flush_queue(ppf, 0);
-    var s =  /*<<format.ml:1105:10>>*/ caml_call1(Stdlib_Buffer[2], buf);
-     /*<<format.ml:1106:2>>*/ caml_call1(Stdlib_Buffer[9], buf);
+    var s =  /*<<format.ml:1105:10>>*/ Stdlib_Buffer[2].call(null, buf);
+     /*<<format.ml:1106:2>>*/ Stdlib_Buffer[9].call(null, buf);
      /*<<format.ml:1106:18>>*/ return s;
     /*<<format.ml:1107:3>>*/ }
    function flush_str_formatter(param){
@@ -27517,20 +27305,22 @@
              function(param){
               var
                buf =
-                  /*<<format.ml:1117:14>>*/ caml_call1
-                  (Stdlib_Buffer[1], pp_buffer_size),
-               output$0 =
-                  /*<<format.ml:1118:18>>*/ caml_call1(Stdlib_Buffer[18], buf);
+                  /*<<format.ml:1117:14>>*/ Stdlib_Buffer[1].call
+                  (null, pp_buffer_size),
+               _G_ =  /*<<format.ml:1119:4>>*/ Stdlib_Buffer[18];
+              function output$0(_H_, _I_, _J_){
+                /*<<format.ml:1118:18>>*/ return _G_(buf, _H_, _I_, _J_);
+              }
               function flush$0(param){
                var
-                _D_ =
-                   /*<<format.ml:1120:37>>*/ caml_call1(Stdlib_Buffer[7], buf);
+                _G_ =
+                   /*<<format.ml:1120:37>>*/ Stdlib_Buffer[7].call(null, buf);
                 /*<<format.ml:1120:13>>*/  /*<<format.ml:1120:6>>*/ caml_call3
                 (output,
-                  /*<<format.ml:1120:13>>*/ caml_call1(Stdlib_Buffer[2], buf),
+                  /*<<format.ml:1120:13>>*/ Stdlib_Buffer[2].call(null, buf),
                  0,
-                 _D_);
-                /*<<format.ml:1121:6>>*/ caml_call1(Stdlib_Buffer[8], buf);
+                 _G_);
+                /*<<format.ml:1121:6>>*/ Stdlib_Buffer[8].call(null, buf);
                 /*<<format.ml:1121:22>>*/ return caml_call1(flush, 0) /*<<format.ml:1122:14>>*/ ;
               }
                /*<<format.ml:1124:4>>*/ return make_formatter
@@ -27538,10 +27328,13 @@
              }) /*<<format.ml:1124:34>>*/ ;
    }
    function synchronized_formatter_of_out_(oc){
-     /*<<format.ml:1127:30>>*/ return  /*<<format.ml:1127:51>>*/ make_synchronized_formatter
-            ( /*<<format.ml:1127:30>>*/ caml_call1(Stdlib[69], oc),
+    var _D_ =  /*<<format.ml:1127:30>>*/ Stdlib[69];
+     /*<<format.ml:1127:51>>*/ return make_synchronized_formatter
+            (function(_E_, _F_, _G_){
+               /*<<format.ml:1127:30>>*/ return _D_(oc, _E_, _F_, _G_);
+             },
              function(param){
-               /*<<format.ml:1127:63>>*/ return caml_call1(Stdlib[63], oc) /*<<format.ml:1127:71>>*/ ;
+               /*<<format.ml:1127:63>>*/ return Stdlib[63].call(null, oc) /*<<format.ml:1127:71>>*/ ;
              }) /*<<format.ml:1127:72>>*/ ;
    }
    function make_symbolic_output_buffer(param){ /*<<format.ml:1154:2>>*/ return [0, 0];
@@ -27551,7 +27344,7 @@
     return 0;
     /*<<format.ml:1157:36>>*/ }
    function get_symbolic_output_buffer(sob){
-     /*<<format.ml:1160:2>>*/ return caml_call1(Stdlib_List[10], sob[1]) /*<<format.ml:1160:39>>*/ ;
+     /*<<format.ml:1160:2>>*/ return Stdlib_List[10].call(null, sob[1]) /*<<format.ml:1160:39>>*/ ;
    }
    function flush_symbolic_output_buffer(sob){
     var items =  /*<<format.ml:1163:14>>*/ get_symbolic_output_buffer(sob);
@@ -27567,8 +27360,8 @@
       /*<<format.ml:1176:48>>*/ return  /*<<format.ml:1176:66>>*/ add_symbolic_output_item
              (sob,
               [0,
-                /*<<format.ml:1176:48>>*/ caml_call3
-                (Stdlib_String[16], s, i, n)]) /*<<format.ml:1176:66>>*/ ;
+                /*<<format.ml:1176:48>>*/ Stdlib_String[16].call
+                (null, s, i, n)]) /*<<format.ml:1176:66>>*/ ;
     }
     function g(param){
       /*<<format.ml:1172:4>>*/ return add_symbolic_output_item(sob, 0);
@@ -28018,15 +27811,16 @@
    }
    function compute_tag(output, tag_acc){
     var
-     buf =  /*<<format.ml:1338:12>>*/ caml_call1(Stdlib_Buffer[1], 16),
+     buf =  /*<<format.ml:1338:12>>*/ Stdlib_Buffer[1].call(null, 16),
      ppf =  /*<<format.ml:1339:12>>*/ formatter_of_buffer(buf);
      /*<<format.ml:1340:2>>*/ caml_call2(output, ppf, tag_acc);
      /*<<format.ml:1341:2>>*/ pp_print_flush(ppf, 0);
-    var len =  /*<<format.ml:1342:12>>*/ caml_call1(Stdlib_Buffer[7], buf);
+    var len =  /*<<format.ml:1342:12>>*/ Stdlib_Buffer[7].call(null, buf);
      /*<<format.ml:1343:2>>*/ return 2 <= len
-            ?  /*<<format.ml:1344:7>>*/ caml_call3
-              (Stdlib_Buffer[4], buf, 1, len - 2 | 0)
-            :  /*<<format.ml:1343:18>>*/ caml_call1(Stdlib_Buffer[2], buf) /*<<format.ml:1344:33>>*/ ;
+            ?  /*<<format.ml:1344:7>>*/ Stdlib_Buffer
+               [4].call
+              (null, buf, 1, len - 2 | 0)
+            :  /*<<format.ml:1343:18>>*/ Stdlib_Buffer[2].call(null, buf) /*<<format.ml:1344:33>>*/ ;
    }
    function output_formatting_lit(ppf, fmting_lit){
      /*<<format.ml:1357:43>>*/ if(typeof fmting_lit === "number")
@@ -28088,8 +27882,7 @@
           var
            _D_ =  /*<<format.ml:1390:43>>*/ compute_tag(output_acc, acc$1),
            match$0 =
-              /*<<format.ml:1390:24>>*/ caml_call1
-              (CamlinternalFormat[20], _D_),
+              /*<<format.ml:1390:24>>*/ CamlinternalFormat[20].call(null, _D_),
            bty =  /*<<format.ml:1390:72>>*/ match$0[2],
            indent = match$0[1];
            /*<<format.ml:1391:4>>*/ return pp_open_box_gen(ppf, indent, bty) /*<<format.ml:1399:34>>*/ ;
@@ -28148,7 +27941,7 @@
          default:
           var msg =  /*<<format.ml:1373:29>>*/ acc[2], p$7 = acc[1];
            /*<<format.ml:1398:32>>*/ output_acc(ppf, p$7);
-           /*<<format.ml:1398:48>>*/ return caml_call1(Stdlib[1], msg) /*<<format.ml:1399:34>>*/ ;
+           /*<<format.ml:1398:48>>*/ return Stdlib[1].call(null, msg) /*<<format.ml:1399:34>>*/ ;
        }
         /*<<format.ml:1395:32>>*/ output_acc(ppf, p$3);
         /*<<format.ml:1395:48>>*/ return pp_print_char(ppf, c) /*<<format.ml:1399:34>>*/ ;
@@ -28157,7 +27950,7 @@
        /*<<format.ml:1381:44>>*/ return  /*<<format.ml:1381:43>>*/ pp_print_as_size
               (ppf,
                size$0,
-                /*<<format.ml:1381:44>>*/ caml_call2(Stdlib_String[1], 1, c$0)) /*<<format.ml:1399:34>>*/ ;
+                /*<<format.ml:1381:44>>*/ Stdlib_String[1].call(null, 1, c$0)) /*<<format.ml:1399:34>>*/ ;
      }
       /*<<format.ml:1393:32>>*/ output_acc(ppf, p$1);
       /*<<format.ml:1393:48>>*/ return pp_print_string(ppf, s) /*<<format.ml:1399:34>>*/ ;
@@ -28195,8 +27988,7 @@
           var
            _v_ =  /*<<format.ml:1425:43>>*/ compute_tag(strput_acc, acc$1),
            match$0 =
-              /*<<format.ml:1425:24>>*/ caml_call1
-              (CamlinternalFormat[20], _v_),
+              /*<<format.ml:1425:24>>*/ CamlinternalFormat[20].call(null, _v_),
            bty =  /*<<format.ml:1425:72>>*/ match$0[2],
            indent = match$0[1];
            /*<<format.ml:1426:4>>*/ return pp_open_box_gen(ppf, indent, bty) /*<<format.ml:1434:34>>*/ ;
@@ -28266,7 +28058,7 @@
          default:
           var msg =  /*<<format.ml:1405:29>>*/ acc[2], p$8 = acc[1];
            /*<<format.ml:1433:32>>*/ strput_acc(ppf, p$8);
-           /*<<format.ml:1433:48>>*/ return caml_call1(Stdlib[1], msg) /*<<format.ml:1434:34>>*/ ;
+           /*<<format.ml:1433:48>>*/ return Stdlib[1].call(null, msg) /*<<format.ml:1434:34>>*/ ;
        }
         /*<<format.ml:1430:32>>*/ strput_acc(ppf, p$3);
         /*<<format.ml:1430:48>>*/ return pp_print_char(ppf, c) /*<<format.ml:1434:34>>*/ ;
@@ -28275,7 +28067,7 @@
        /*<<format.ml:1413:44>>*/ return  /*<<format.ml:1413:43>>*/ pp_print_as_size
               (ppf,
                size$0,
-                /*<<format.ml:1413:44>>*/ caml_call2(Stdlib_String[1], 1, c$0)) /*<<format.ml:1434:34>>*/ ;
+                /*<<format.ml:1413:44>>*/ Stdlib_String[1].call(null, 1, c$0)) /*<<format.ml:1434:34>>*/ ;
      }
       /*<<format.ml:1428:32>>*/ strput_acc(ppf, p$1);
       /*<<format.ml:1428:48>>*/ return pp_print_string(ppf, s) /*<<format.ml:1434:34>>*/ ;
@@ -28285,8 +28077,8 @@
    }
    function kfprintf(k, ppf, param){
     var fmt =  /*<<format.ml:1442:13>>*/ param[1];
-     /*<<format.ml:1443:2>>*/ return caml_call3
-            (CamlinternalFormat[7],
+     /*<<format.ml:1443:2>>*/ return CamlinternalFormat[7].call
+            (null,
              function(acc){
                /*<<format.ml:1444:16>>*/ output_acc(ppf, acc);
                /*<<format.ml:1444:34>>*/ return caml_call1(k, ppf) /*<<format.ml:1444:41>>*/ ;
@@ -28296,16 +28088,13 @@
    }
    function ikfprintf(k, ppf, param){
     var fmt =  /*<<format.ml:1447:14>>*/ param[1];
-     /*<<format.ml:1448:2>>*/ return caml_call3
-            (CamlinternalFormat[8], k, ppf, fmt) /*<<format.ml:1448:24>>*/ ;
+     /*<<format.ml:1448:2>>*/ return CamlinternalFormat[8].call
+            (null, k, ppf, fmt) /*<<format.ml:1448:24>>*/ ;
    }
    function ifprintf(ppf, param){
     var fmt =  /*<<format.ml:1450:13>>*/ param[1];
-     /*<<format.ml:1451:2>>*/ return caml_call3
-            (CamlinternalFormat[8],
-             function(_n_){ /*<<?>>*/ return 0;},
-             0,
-             fmt) /*<<format.ml:1451:28>>*/ ;
+     /*<<format.ml:1451:2>>*/ return CamlinternalFormat[8].call
+            (null, function(_n_){ /*<<?>>*/ return 0;}, 0, fmt) /*<<format.ml:1451:28>>*/ ;
    }
    function fprintf(ppf){
     function _m_(_n_){ /*<<?>>*/ return 0;}
@@ -28314,8 +28103,8 @@
     /*<<format.ml:1453:37>>*/ }
    function printf(param){
     var fmt =  /*<<format.ml:1455:11>>*/ param[1];
-     /*<<format.ml:1456:2>>*/ return caml_call3
-            (CamlinternalFormat[7],
+     /*<<format.ml:1456:2>>*/ return CamlinternalFormat[7].call
+            (null,
              function(acc){
                /*<<format.ml:1457:27>>*/ return  /*<<format.ml:1457:54>>*/ output_acc
                       ( /*<<format.ml:1457:27>>*/ caml_call1
@@ -28327,8 +28116,8 @@
    }
    function eprintf(param){
     var fmt =  /*<<format.ml:1460:12>>*/ param[1];
-     /*<<format.ml:1461:2>>*/ return caml_call3
-            (CamlinternalFormat[7],
+     /*<<format.ml:1461:2>>*/ return CamlinternalFormat[7].call
+            (null,
              function(acc){
                /*<<format.ml:1462:27>>*/ return  /*<<format.ml:1462:54>>*/ output_acc
                       ( /*<<format.ml:1462:27>>*/ caml_call1
@@ -28340,8 +28129,8 @@
    }
    function kdprintf(k, param){
     var fmt =  /*<<format.ml:1465:13>>*/ param[1];
-     /*<<format.ml:1466:2>>*/ return caml_call3
-            (CamlinternalFormat[7],
+     /*<<format.ml:1466:2>>*/ return CamlinternalFormat[7].call
+            (null,
              function(acc){
                /*<<format.ml:1467:16>>*/ return caml_call1
                       (k,
@@ -28369,8 +28158,8 @@
       /*<<format.ml:1477:6>>*/ return  /*<<format.ml:1477:36>>*/ caml_call1
              (k,  /*<<format.ml:1477:6>>*/ flush_buffer_formatter(b, ppf)) /*<<format.ml:1477:36>>*/ ;
     }
-     /*<<format.ml:1478:2>>*/ return caml_call3
-            (CamlinternalFormat[7], k$0, 0, fmt) /*<<format.ml:1478:30>>*/ ;
+     /*<<format.ml:1478:2>>*/ return CamlinternalFormat[7].call
+            (null, k$0, 0, fmt) /*<<format.ml:1478:30>>*/ ;
    }
    function sprintf(fmt){
      /*<<format.ml:1481:18>>*/ return ksprintf(id, fmt) /*<<format.ml:1481:33>>*/ ;
@@ -28385,8 +28174,8 @@
       /*<<format.ml:1488:6>>*/ return  /*<<format.ml:1488:36>>*/ caml_call1
              (k,  /*<<format.ml:1488:6>>*/ flush_buffer_formatter(b, ppf)) /*<<format.ml:1488:36>>*/ ;
     }
-     /*<<format.ml:1489:2>>*/ return caml_call3
-            (CamlinternalFormat[7], k$0, 0, fmt) /*<<format.ml:1489:30>>*/ ;
+     /*<<format.ml:1489:2>>*/ return CamlinternalFormat[7].call
+            (null, k$0, 0, fmt) /*<<format.ml:1489:30>>*/ ;
    }
    function asprintf(fmt){
      /*<<format.ml:1492:19>>*/ return kasprintf(id, fmt) /*<<format.ml:1492:35>>*/ ;
@@ -28401,10 +28190,9 @@
               (Stdlib_Domain[11][2], err_formatter_key),
              0) /*<<format.ml:1498:47>>*/ ;
    }
-    /*<<format.ml:1500:9>>*/ caml_call1
-    (Stdlib[100], flush_standard_formatters);
-    /*<<format.ml:1502:9>>*/ caml_call1
-    (Stdlib_Domain[5],
+    /*<<format.ml:1500:9>>*/ Stdlib[100].call(null, flush_standard_formatters);
+    /*<<format.ml:1502:9>>*/ Stdlib_Domain[5].call
+    (null,
      function(param){
        /*<<format.ml:1503:2>>*/ flush_standard_formatters(0);
       var
@@ -28645,11 +28433,6 @@
             ? 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,
@@ -28735,8 +28518,8 @@
    function token_string(ib){
     var
      token_buffer =  /*<<scanf.ml:227:4>>*/ ib[8],
-     tok =  /*<<scanf.ml:228:14>>*/ caml_call1(Stdlib_Buffer[2], token_buffer);
-     /*<<scanf.ml:229:4>>*/ caml_call1(Stdlib_Buffer[8], token_buffer);
+     tok =  /*<<scanf.ml:228:14>>*/ Stdlib_Buffer[2].call(null, token_buffer);
+     /*<<scanf.ml:229:4>>*/ Stdlib_Buffer[8].call(null, token_buffer);
      /*<<scanf.ml:229:29>>*/ ib[6] = ib[6] + 1 | 0;
      /*<<scanf.ml:231:4>>*/ return tok;
     /*<<scanf.ml:231:7>>*/ }
@@ -28746,7 +28529,7 @@
      /*<<scanf.ml:237:30>>*/ return width$0;
     /*<<scanf.ml:241:53>>*/ }
    function store_char(width, ib, c){
-     /*<<scanf.ml:244:4>>*/ caml_call2(Stdlib_Buffer[12], ib[8], c);
+     /*<<scanf.ml:244:4>>*/ Stdlib_Buffer[12].call(null, ib[8], c);
      /*<<scanf.ml:244:40>>*/ return ignore_char(width, ib) /*<<scanf.ml:245:24>>*/ ;
    }
    var default_token_buffer_size =  /*<<?>>*/ 1024;
@@ -28759,7 +28542,7 @@
             0,
             0,
             next,
-            caml_call1(Stdlib_Buffer[1], default_token_buffer_size),
+            Stdlib_Buffer[1].call(null, default_token_buffer_size),
             iname] /*<<scanf.ml:258:61>>*/ ;
     /*<<scanf.ml:260:3>>*/ }
    function from_string(s){
@@ -28780,7 +28563,7 @@
    function from_function(_aw_){return create(_a_, _aw_);}
    var len =  /*<<scanf.ml:274:42>>*/ 1024;
    function scan_close_at_end(ic){
-     /*<<scanf.ml:320:29>>*/ caml_call1(Stdlib[93], ic);
+     /*<<scanf.ml:320:29>>*/ Stdlib[93].call(null, ic);
      /*<<scanf.ml:320:47>>*/ throw caml_maybe_attach_backtrace(Stdlib[12], 1);
     /*<<scanf.ml:320:66>>*/ }
    function scan_raise_at_end(ic){
@@ -28801,7 +28584,7 @@
       /*<<scanf.ml:334:6>>*/ if(eof[1])
        /*<<scanf.ml:334:19>>*/ throw caml_maybe_attach_backtrace
              (Stdlib[12], 1);
-      /*<<scanf.ml:335:15>>*/ lim[1] = caml_call4(Stdlib[84], ic, buf, 0, len);
+      /*<<scanf.ml:335:15>>*/ lim[1] = Stdlib[84].call(null, ic, buf, 0, len);
       /*<<scanf.ml:336:8>>*/ return 0 === lim[1]
              ? (eof
                 [1]
@@ -28836,10 +28619,10 @@
     if(typeof match === "number")  /*<<scanf.ml:389:37>>*/ return 0;
      /*<<scanf.ml:385:4>>*/ if(0 === match[0]){
      var ic = match[1];
-      /*<<scanf.ml:387:6>>*/ return caml_call1(Stdlib[93], ic) /*<<scanf.ml:389:39>>*/ ;
+      /*<<scanf.ml:387:6>>*/ return Stdlib[93].call(null, ic) /*<<scanf.ml:389:39>>*/ ;
     }
     var ic$0 =  /*<<scanf.ml:385:4>>*/ match[2];
-     /*<<scanf.ml:388:32>>*/ return caml_call1(Stdlib[93], ic$0) /*<<scanf.ml:389:39>>*/ ;
+     /*<<scanf.ml:388:32>>*/ return Stdlib[93].call(null, ic$0) /*<<scanf.ml:389:39>>*/ ;
    }
    var
     Scan_failure =
@@ -28936,19 +28719,21 @@
     /*<<scanf.ml:405:40>>*/ }
    function bad_input_escape(c){
      /*<<scanf.ml:408:12>>*/ return  /*<<scanf.ml:408:60>>*/ bad_input
-            ( /*<<scanf.ml:408:12>>*/ caml_call2(Stdlib_Printf[4], _d_, c)) /*<<scanf.ml:408:60>>*/ ;
+            ( /*<<scanf.ml:408:12>>*/ caml_call1
+              (Stdlib_Printf[4].call(null, _d_), c)) /*<<scanf.ml:408:60>>*/ ;
    }
    function bad_token_length(message){
      /*<<scanf.ml:413:4>>*/ return  /*<<scanf.ml:416:15>>*/ bad_input
-            ( /*<<scanf.ml:413:4>>*/ caml_call2
-              (Stdlib_Printf[4], _e_, message)) /*<<scanf.ml:416:15>>*/ ;
+            ( /*<<scanf.ml:413:4>>*/ caml_call1
+              (Stdlib_Printf[4].call(null, _e_), message)) /*<<scanf.ml:416:15>>*/ ;
    }
    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:436:2>>*/ return  /*<<scanf.ml:440:41>>*/ bad_input
-            ( /*<<scanf.ml:436:2>>*/ caml_call3(Stdlib_Printf[4], _g_, c, ci)) /*<<scanf.ml:440:41>>*/ ;
+            ( /*<<scanf.ml:436:2>>*/ caml_call2
+              (Stdlib_Printf[4].call(null, _g_), c, ci)) /*<<scanf.ml:440:41>>*/ ;
    }
    function check_char(ib, c$0){
      /*<<scanf.ml:468:2>>*/ if(10 === c$0){
@@ -28997,7 +28782,8 @@
             ? s
               !== "true"
               ?  /*<<scanf.ml:496:60>>*/ bad_input
-                ( /*<<scanf.ml:496:19>>*/ caml_call2(Stdlib_Printf[4], _h_, s))
+                ( /*<<scanf.ml:496:19>>*/ caml_call1
+                  (Stdlib_Printf[4].call(null, _h_), s))
               : 1
             : 0 /*<<scanf.ml:496:60>>*/ ;
    }
@@ -29028,29 +28814,29 @@
        var
         _as_ =  /*<<scanf.ml:529:29>>*/ token_string(ib),
         tok =
-           /*<<scanf.ml:529:46>>*/  /*<<scanf.ml:529:22>>*/ caml_call2
-           (Stdlib[28], cst_0b, _as_);
+           /*<<scanf.ml:529:46>>*/  /*<<scanf.ml:529:22>>*/ Stdlib[28].call
+           (null, cst_0b, _as_);
        break;
       case 3:
        var
         _at_ =  /*<<scanf.ml:527:29>>*/ token_string(ib),
         tok =
-           /*<<scanf.ml:527:46>>*/  /*<<scanf.ml:527:22>>*/ caml_call2
-           (Stdlib[28], cst_0o, _at_);
+           /*<<scanf.ml:527:46>>*/  /*<<scanf.ml:527:22>>*/ Stdlib[28].call
+           (null, cst_0o, _at_);
        break;
       case 4:
        var
         _au_ =  /*<<scanf.ml:526:29>>*/ token_string(ib),
         tok =
-           /*<<scanf.ml:526:46>>*/  /*<<scanf.ml:526:22>>*/ caml_call2
-           (Stdlib[28], cst_0u, _au_);
+           /*<<scanf.ml:526:46>>*/  /*<<scanf.ml:526:22>>*/ Stdlib[28].call
+           (null, cst_0u, _au_);
        break;
       case 5:
        var
         _av_ =  /*<<scanf.ml:528:29>>*/ token_string(ib),
         tok =
-           /*<<scanf.ml:528:46>>*/  /*<<scanf.ml:528:22>>*/ caml_call2
-           (Stdlib[28], cst_0x, _av_);
+           /*<<scanf.ml:528:46>>*/  /*<<scanf.ml:528:22>>*/ Stdlib[28].call
+           (null, cst_0x, _av_);
        break;
       default:
        var
@@ -29060,8 +28846,8 @@
     var l =  /*<<scanf.ml:530:2>>*/ caml_ml_string_length(tok);
      /*<<scanf.ml:531:2>>*/ if
      (0 !== l && 43 ===  /*<<scanf.ml:531:14>>*/ caml_string_get(tok, 0))
-      /*<<scanf.ml:531:43>>*/ return caml_call3
-             (Stdlib_String[16], tok, 1, l - 1 | 0) /*<<scanf.ml:531:67>>*/ ;
+      /*<<scanf.ml:531:43>>*/ return Stdlib_String[16].call
+             (null, tok, 1, l - 1 | 0) /*<<scanf.ml:531:67>>*/ ;
      /*<<scanf.ml:531:34>>*/ return tok;
     /*<<scanf.ml:531:67>>*/ }
    function token_float(ib){
@@ -29095,7 +28881,8 @@
     var c =  /*<<scanf.ml:590:10>>*/ checked_peek_char(ib);
      /*<<scanf.ml:591:2>>*/ if(9 < c - 48 >>> 0)
       /*<<scanf.ml:596:14>>*/ return  /*<<scanf.ml:596:70>>*/ bad_input
-             ( /*<<scanf.ml:596:14>>*/ caml_call2(Stdlib_Printf[4], _j_, c)) /*<<scanf.ml:596:70>>*/ ;
+             ( /*<<scanf.ml:596:14>>*/ caml_call1
+               (Stdlib_Printf[4].call(null, _j_), c)) /*<<scanf.ml:596:70>>*/ ;
     var width$0 =  /*<<scanf.ml:593:16>>*/ store_char(width, ib, c);
      /*<<scanf.ml:594:4>>*/ return scan_decimal_digit_star(width$0, ib) /*<<scanf.ml:596:70>>*/ ;
    }
@@ -29105,8 +28892,8 @@
     var c$0 =  /*<<scanf.ml:621:10>>*/ checked_peek_char(ib);
      /*<<scanf.ml:622:5>>*/ if(! caml_call1(digitp, c$0))
       /*<<scanf.ml:626:14>>*/ return  /*<<scanf.ml:626:77>>*/ bad_input
-             ( /*<<scanf.ml:626:14>>*/ caml_call3
-               (Stdlib_Printf[4], _k_, c$0, basis)) /*<<scanf.ml:626:77>>*/ ;
+             ( /*<<scanf.ml:626:14>>*/ caml_call2
+               (Stdlib_Printf[4].call(null, _k_), c$0, basis)) /*<<scanf.ml:626:77>>*/ ;
     var
      width$3 =  /*<<scanf.ml:623:16>>*/ store_char(width$2, ib, c$0),
      width =  /*<<scanf.ml:624:4>>*/ width$3;
@@ -29211,12 +28998,12 @@
       case 0:
         /*<<scanf.ml:634:22>>*/ return scan_digit_plus
                (cst_binary, is_binary_digit, width$1, ib) /*<<scanf.ml:697:49>>*/ ;
-      case 3:
-        /*<<scanf.ml:641:21>>*/ return scan_digit_plus
-               (cst_octal, is_octal_digit, width$1, ib) /*<<scanf.ml:697:49>>*/ ;
-      default:
+      case 5:
         /*<<scanf.ml:648:27>>*/ return scan_digit_plus
                (cst_hexadecimal, is_hexa_digit, width$1, ib) /*<<scanf.ml:697:49>>*/ ;
+      default:
+        /*<<scanf.ml:641:21>>*/ return scan_digit_plus
+               (cst_octal, is_octal_digit, width$1, ib) /*<<scanf.ml:697:49>>*/ ;
     }
    }
    function scan_fractional_part(width, ib){
@@ -29257,7 +29044,7 @@
     var
      width$2 =  /*<<scanf.ml:771:16>>*/ store_char(width$0, ib, c),
      precision$0 =
-        /*<<scanf.ml:772:20>>*/ caml_call2(Stdlib_Int[10], width$2, precision),
+        /*<<scanf.ml:772:20>>*/ Stdlib_Int[10].call(null, width$2, precision),
      width$3 =
         /*<<scanf.ml:773:37>>*/ width$2
        - (precision$0 - scan_fractional_part(precision$0, ib) | 0)
@@ -29270,8 +29057,9 @@
     function lowercase(c){
       /*<<scanf.ml:781:4>>*/ return 25 < c - 65 >>> 0
              ? c
-             :  /*<<scanf.ml:783:6>>*/ caml_call1
-               (Stdlib[29], (c - 65 | 0) + 97 | 0) /*<<scanf.ml:784:12>>*/ ;
+             :  /*<<scanf.ml:783:6>>*/ Stdlib
+                [29].call
+               (null, (c - 65 | 0) + 97 | 0) /*<<scanf.ml:784:12>>*/ ;
     }
     var
      len =  /*<<scanf.ml:785:2>>*/ caml_ml_string_length(str),
@@ -29370,8 +29158,8 @@
            else
             var
              precision$0 =
-                /*<<scanf.ml:817:32>>*/ caml_call2
-                (Stdlib_Int[10], width$6, precision),
+                /*<<scanf.ml:817:32>>*/ Stdlib_Int[10].call
+                (null, width$6, precision),
              width$7 =
                 /*<<scanf.ml:818:70>>*/ width$6
                -
@@ -29438,8 +29226,8 @@
       var
        width$1 =  /*<<scanf.ml:847:16>>*/ store_char(width$0, ib, c),
        precision$0 =
-          /*<<scanf.ml:850:20>>*/ caml_call2
-          (Stdlib_Int[10], width$1, precision),
+          /*<<scanf.ml:850:20>>*/ Stdlib_Int[10].call
+          (null, width$1, precision),
        width_precision =
           /*<<scanf.ml:853:26>>*/ scan_fractional_part(precision$0, ib),
        frac_width =  /*<<scanf.ml:856:4>>*/ precision$0 - width_precision | 0,
@@ -29525,8 +29313,8 @@
         if(112 === match){var width$5 = width$4; break a;}
         var
          precision$0 =
-            /*<<scanf.ml:886:30>>*/ caml_call2
-            (Stdlib_Int[10], width$4, precision),
+            /*<<scanf.ml:886:30>>*/ Stdlib_Int[10].call
+            (null, width$4, precision),
          width$5 =
             /*<<scanf.ml:887:68>>*/ width$4
            -
@@ -29608,8 +29396,8 @@
     var c =  /*<<scanf.ml:996:10>>*/ peek_char(ib);
      /*<<scanf.ml:997:20>>*/ return ib[1]
             ?  /*<<scanf.ml:424:15>>*/ bad_input
-              ( /*<<scanf.ml:421:4>>*/ caml_call2
-                (Stdlib_Printf[4], _f_, message))
+              ( /*<<scanf.ml:421:4>>*/ caml_call1
+                (Stdlib_Printf[4].call(null, _f_), message))
             : c /*<<scanf.ml:998:3>>*/ ;
    }
    function scan_backslash_char(width, ib){
@@ -29638,14 +29426,14 @@
        b:
        {
          /*<<scanf.ml:959:2>>*/ if(0 <= c && 255 >= c){
-         var _O_ =  /*<<scanf.ml:963:2>>*/ caml_call1(Stdlib[29], c);
+         var _O_ =  /*<<scanf.ml:963:2>>*/ Stdlib[29].call(null, c);
          break b;
         }
         var
          _O_ =
             /*<<scanf.ml:962:60>>*/ bad_input
-            ( /*<<scanf.ml:961:6>>*/ caml_call4
-              (Stdlib_Printf[4], _l_, c0, c1$0, c2$0));
+            ( /*<<scanf.ml:961:6>>*/ caml_call3
+              (Stdlib_Printf[4].call(null, _l_), c0, c1$0, c2$0));
        }
         /*<<scanf.ml:1017:71>>*/ return store_char(width - 2 | 0, ib, _O_) /*<<scanf.ml:1028:22>>*/ ;
       }
@@ -29679,14 +29467,14 @@
          b:
          {
            /*<<scanf.ml:986:2>>*/ if(0 <= c$0 && 255 >= c$0){
-           var _N_ =  /*<<scanf.ml:989:2>>*/ caml_call1(Stdlib[29], c$0);
+           var _N_ =  /*<<scanf.ml:989:2>>*/ Stdlib[29].call(null, c$0);
            break b;
           }
           var
            _N_ =
               /*<<scanf.ml:988:72>>*/ bad_input
-              ( /*<<scanf.ml:988:6>>*/ caml_call3
-                (Stdlib_Printf[4], _m_, c1, c2));
+              ( /*<<scanf.ml:988:6>>*/ caml_call2
+                (Stdlib_Printf[4].call(null, _m_), c1, c2));
          }
           /*<<scanf.ml:1026:72>>*/ return store_char(width - 2 | 0, ib, _N_) /*<<scanf.ml:1028:22>>*/ ;
         case 0:
@@ -29794,8 +29582,8 @@
        if(_K_)
         var
          _L_ =
-            /*<<scanf.ml:1106:7>>*/ caml_call2
-            (CamlinternalFormat[1], char_set, c),
+            /*<<scanf.ml:1106:7>>*/ CamlinternalFormat[1].call
+            (null, char_set, c),
          _I_ =  /*<<scanf.ml:1106:32>>*/ _L_ ? c !== stp ? 1 : 0 : _L_;
        else
         var _I_ =  /*<<scanf.ml:1105:37>>*/ _K_;
@@ -29830,7 +29618,8 @@
     }
     var i =  /*<<scanf.ml:1124:12>>*/ char_count(ib);
      /*<<scanf.ml:1125:14>>*/ return  /*<<scanf.ml:1125:75>>*/ bad_input
-            ( /*<<scanf.ml:1125:14>>*/ caml_call3(Stdlib_Printf[4], _o_, i, s)) /*<<scanf.ml:1126:16>>*/ ;
+            ( /*<<scanf.ml:1125:14>>*/ caml_call2
+              (Stdlib_Printf[4].call(null, _o_), i, s)) /*<<scanf.ml:1126:16>>*/ ;
    }
    function width_of_pad_opt(pad_opt){
      /*<<scanf.ml:1138:31>>*/ if(! pad_opt)
@@ -29842,12 +29631,11 @@
      /*<<scanf.ml:1144:2>>*/ if(6 === fmting)
       /*<<scanf.ml:1144:35>>*/ return _p_;
     var
-     str =
-        /*<<scanf.ml:1145:14>>*/ caml_call1(CamlinternalFormat[17], fmting),
+     str =  /*<<scanf.ml:1145:14>>*/ CamlinternalFormat[17].call(null, fmting),
      stp =  /*<<scanf.ml:1146:14>>*/ caml_string_get(str, 1),
      sub_str =
-        /*<<scanf.ml:1147:4>>*/  /*<<scanf.ml:1147:18>>*/ caml_call3
-        (Stdlib_String[16],
+        /*<<scanf.ml:1147:4>>*/  /*<<scanf.ml:1147:18>>*/ Stdlib_String[16].call
+        (null,
          str,
          2,
           /*<<scanf.ml:1147:4>>*/ caml_ml_string_length(str) - 2 | 0);
@@ -29921,11 +29709,10 @@
           rest$13 =  /*<<scanf.ml:1161:13>>*/ fmt[3],
           fmtty = fmt[2],
           _I_ =
-             /*<<scanf.ml:1195:44>>*/ caml_call1
-             (CamlinternalFormat[21], fmtty),
+             /*<<scanf.ml:1195:44>>*/ CamlinternalFormat[21].call(null, fmtty),
           _H_ =
-             /*<<scanf.ml:1195:33>>*/ caml_call1
-             (CamlinternalFormatBasics[2], _I_);
+             /*<<scanf.ml:1195:33>>*/ CamlinternalFormatBasics[2].call
+             (null, _I_);
           /*<<scanf.ml:1195:57>>*/ if(counter >= 50)
           return caml_trampoline_return
                   (take_fmtty_format_readers$0, [0, k, _H_, rest$13]) /*<<scanf.ml:1198:45>>*/ ;
@@ -29950,8 +29737,8 @@
            rest$17 = fmt[2],
            fmt$0 = _G_[1][1],
            fmt$1 =
-              /*<<scanf.ml:1189:28>>*/ caml_call2
-              (CamlinternalFormatBasics[3], fmt$0, rest$17);
+              /*<<scanf.ml:1189:28>>*/ CamlinternalFormatBasics[3].call
+              (null, fmt$0, rest$17);
            /*<<scanf.ml:1189:49>>*/ fmt = fmt$1;
          }
          else{
@@ -29959,8 +29746,8 @@
            rest$18 =  /*<<scanf.ml:1161:13>>*/ fmt[2],
            fmt$2 = _G_[1][1],
            fmt$3 =
-              /*<<scanf.ml:1191:28>>*/ caml_call2
-              (CamlinternalFormatBasics[3], fmt$2, rest$18);
+              /*<<scanf.ml:1191:28>>*/ CamlinternalFormatBasics[3].call
+              (null, fmt$2, rest$18);
            /*<<scanf.ml:1191:49>>*/ fmt = fmt$3;
          }
          break;
@@ -30072,13 +29859,13 @@
          ty2 = fmtty[2],
          ty1 = fmtty[1],
          _G_ =
-            /*<<scanf.ml:1227:19>>*/ caml_call1(CamlinternalFormat[21], ty1),
+            /*<<scanf.ml:1227:19>>*/ CamlinternalFormat[21].call(null, ty1),
          ty =
-            /*<<scanf.ml:1227:13>>*/ caml_call2
-            (CamlinternalFormat[22], _G_, ty2),
+            /*<<scanf.ml:1227:13>>*/ CamlinternalFormat[22].call
+            (null, _G_, ty2),
          fmtty$9 =
-            /*<<scanf.ml:1228:32>>*/ caml_call2
-            (CamlinternalFormatBasics[1], ty, rest);
+            /*<<scanf.ml:1228:32>>*/ CamlinternalFormatBasics[1].call
+            (null, ty, rest);
          /*<<scanf.ml:1228:54>>*/ fmtty = fmtty$9;
         break;
        case 10:
@@ -30198,8 +29985,8 @@
                 };
               /*<<scanf.ml:1283:22>>*/ return  /*<<scanf.ml:1283:44>>*/ pad_prec_scanf
                      (ib,
-                       /*<<scanf.ml:1283:22>>*/ caml_call2
-                       (CamlinternalFormatBasics[3], fmt$0, rest$3),
+                       /*<<scanf.ml:1283:22>>*/ CamlinternalFormatBasics[3].call
+                       (null, fmt$0, rest$3),
                       readers,
                       pad,
                       0,
@@ -30215,8 +30002,8 @@
                };
              /*<<scanf.ml:1287:22>>*/ return  /*<<scanf.ml:1287:44>>*/ pad_prec_scanf
                     (ib,
-                      /*<<scanf.ml:1287:22>>*/ caml_call2
-                      (CamlinternalFormatBasics[3], fmt$1, rest$4),
+                      /*<<scanf.ml:1287:22>>*/ CamlinternalFormatBasics[3].call
+                      (null, fmt$1, rest$4),
                      readers,
                      pad,
                      0,
@@ -30249,8 +30036,8 @@
          iconv = fmt[1],
          conv =
             /*<<scanf.ml:1297:39>>*/  /*<<scanf.ml:1297:12>>*/ integer_conversion_of_char
-            ( /*<<scanf.ml:1297:39>>*/ caml_call1
-              (CamlinternalFormat[16], iconv)),
+            ( /*<<scanf.ml:1297:39>>*/ CamlinternalFormat[16].call
+              (null, iconv)),
          scan$4 =
             /*<<scanf.ml:1298:4>>*/ function(width, param, ib){
              /*<<scanf.ml:1298:26>>*/ return scan_int_conversion
@@ -30275,8 +30062,8 @@
          iconv$0 = fmt[1],
          conv$0 =
             /*<<scanf.ml:1301:39>>*/  /*<<scanf.ml:1301:12>>*/ integer_conversion_of_char
-            ( /*<<scanf.ml:1301:39>>*/ caml_call1
-              (CamlinternalFormat[16], iconv$0)),
+            ( /*<<scanf.ml:1301:39>>*/ CamlinternalFormat[16].call
+              (null, iconv$0)),
          scan$5 =
             /*<<scanf.ml:1302:4>>*/ function(width, param, ib){
              /*<<scanf.ml:1302:26>>*/ return scan_int_conversion
@@ -30301,8 +30088,8 @@
          iconv$1 = fmt[1],
          conv$1 =
             /*<<scanf.ml:1305:39>>*/  /*<<scanf.ml:1305:12>>*/ integer_conversion_of_char
-            ( /*<<scanf.ml:1305:39>>*/ caml_call1
-              (CamlinternalFormat[16], iconv$1)),
+            ( /*<<scanf.ml:1305:39>>*/ CamlinternalFormat[16].call
+              (null, iconv$1)),
          scan$6 =
             /*<<scanf.ml:1306:4>>*/ function(width, param, ib){
              /*<<scanf.ml:1306:26>>*/ return scan_int_conversion
@@ -30327,8 +30114,8 @@
          iconv$2 = fmt[1],
          conv$2 =
             /*<<scanf.ml:1309:39>>*/  /*<<scanf.ml:1309:12>>*/ integer_conversion_of_char
-            ( /*<<scanf.ml:1309:39>>*/ caml_call1
-              (CamlinternalFormat[16], iconv$2)),
+            ( /*<<scanf.ml:1309:39>>*/ CamlinternalFormat[16].call
+              (null, iconv$2)),
          scan$7 =
             /*<<scanf.ml:1310:4>>*/ function(width, param, ib){
              /*<<scanf.ml:1310:26>>*/ return scan_int_conversion
@@ -30401,8 +30188,8 @@
                   === c
                   ? 4
                   :  /*<<scanf.ml:1095:6>>*/ bad_input
-                    ( /*<<scanf.ml:1096:8>>*/ caml_call2
-                      (Stdlib_Printf[4], _n_, c));
+                    ( /*<<scanf.ml:1096:8>>*/ caml_call1
+                      (Stdlib_Printf[4].call(null, _n_), c));
              /*<<scanf.ml:1097:2>>*/ return scan_string(0, m, ib) /*<<scanf.ml:1320:34>>*/ ;
            };
          /*<<scanf.ml:1321:4>>*/ return pad_prec_scanf
@@ -30415,8 +30202,8 @@
         break;
        case 11:
         var rest$15 =  /*<<scanf.ml:1266:22>>*/ fmt[2], str$0 = fmt[1];
-         /*<<scanf.ml:1341:4>>*/ caml_call2
-         (Stdlib_String[30],
+         /*<<scanf.ml:1341:4>>*/ Stdlib_String[30].call
+         (null,
           function(_G_){ /*<<scanf.ml:1341:16>>*/ return check_char(ib, _G_);},
           str$0);
          /*<<scanf.ml:1341:35>>*/ fmt = rest$15;
@@ -30437,8 +30224,8 @@
          /*<<scanf.ml:1350:4>>*/ try{
          var
           _B_ =
-             /*<<scanf.ml:1351:10>>*/ caml_call2
-             (CamlinternalFormat[14], s, fmtty),
+             /*<<scanf.ml:1351:10>>*/ CamlinternalFormat[14].call
+             (null, s, fmtty),
           fmt$2 = _B_;
         }
         catch(exn$0){
@@ -30463,28 +30250,28 @@
          /*<<scanf.ml:1358:4>>*/ try{
          var
           fmt$5 =
-             /*<<scanf.ml:1360:26>>*/ caml_call2
-              (CamlinternalFormat[13], 0, s$0)
+             /*<<scanf.ml:1360:26>>*/ CamlinternalFormat[13].call
+              (null, 0, s$0)
              [1],
           fmt$6 =
-             /*<<scanf.ml:1361:27>>*/ caml_call2
-              (CamlinternalFormat[13], 0, s$0)
+             /*<<scanf.ml:1361:27>>*/ CamlinternalFormat[13].call
+              (null, 0, s$0)
              [1],
           _C_ =
-             /*<<scanf.ml:1375:36>>*/ caml_call1
-             (CamlinternalFormat[21], fmtty$0),
+             /*<<scanf.ml:1375:36>>*/ CamlinternalFormat[21].call
+             (null, fmtty$0),
           _D_ =
-             /*<<scanf.ml:1375:25>>*/ caml_call1
-             (CamlinternalFormatBasics[2], _C_),
+             /*<<scanf.ml:1375:25>>*/ CamlinternalFormatBasics[2].call
+             (null, _C_),
           fmt$7 =
-             /*<<scanf.ml:1375:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$6, _D_),
+             /*<<scanf.ml:1375:8>>*/ CamlinternalFormat[12].call
+             (null, fmt$6, _D_),
           _E_ =
-             /*<<scanf.ml:1374:24>>*/ caml_call1
-             (CamlinternalFormatBasics[2], fmtty$0),
+             /*<<scanf.ml:1374:24>>*/ CamlinternalFormatBasics[2].call
+             (null, fmtty$0),
           _F_ =
-             /*<<scanf.ml:1374:8>>*/ caml_call2
-             (CamlinternalFormat[12], fmt$5, _E_),
+             /*<<scanf.ml:1374:8>>*/ CamlinternalFormat[12].call
+             (null, fmt$5, _E_),
           fmt$4 = fmt$7,
           fmt$3 = _F_;
         }
@@ -30501,24 +30288,24 @@
                 [0, fmt$3, s$0],
                  /*<<scanf.ml:1379:10>>*/ make_scanf
                  (ib,
-                   /*<<scanf.ml:1379:24>>*/ caml_call2
-                   (CamlinternalFormatBasics[3], fmt$4, rest$18),
+                   /*<<scanf.ml:1379:24>>*/ CamlinternalFormatBasics[3].call
+                   (null, fmt$4, rest$18),
                   readers)] /*<<scanf.ml:1379:54>>*/ ;
        case 15:
-         /*<<scanf.ml:1323:4>>*/ return caml_call1
-                (Stdlib[1], cst_scanf_bad_conversion_a) /*<<scanf.ml:1418:7>>*/ ;
+         /*<<scanf.ml:1323:4>>*/ return Stdlib[1].call
+                (null, cst_scanf_bad_conversion_a) /*<<scanf.ml:1418:7>>*/ ;
        case 16:
-         /*<<scanf.ml:1325:4>>*/ return caml_call1
-                (Stdlib[1], cst_scanf_bad_conversion_t) /*<<scanf.ml:1418:7>>*/ ;
+         /*<<scanf.ml:1325:4>>*/ return Stdlib[1].call
+                (null, cst_scanf_bad_conversion_t) /*<<scanf.ml:1418:7>>*/ ;
        case 17:
         var
          rest$19 =  /*<<scanf.ml:1266:22>>*/ fmt[2],
          formatting_lit = fmt[1],
          _G_ =
-            /*<<scanf.ml:1401:32>>*/ caml_call1
-            (CamlinternalFormat[17], formatting_lit);
-         /*<<scanf.ml:1401:4>>*/ caml_call2
-         (Stdlib_String[30],
+            /*<<scanf.ml:1401:32>>*/ CamlinternalFormat[17].call
+            (null, formatting_lit);
+         /*<<scanf.ml:1401:4>>*/ Stdlib_String[30].call
+         (null,
           function(_G_){ /*<<scanf.ml:1401:16>>*/ return check_char(ib, _G_);},
           _G_);
          /*<<scanf.ml:1401:73>>*/ fmt = rest$19;
@@ -30531,8 +30318,8 @@
           /*<<scanf.ml:1404:23>>*/ check_char(ib, 123);
          var
           fmt$9 =
-             /*<<scanf.ml:1405:18>>*/ caml_call2
-             (CamlinternalFormatBasics[3], fmt$8, rest$20);
+             /*<<scanf.ml:1405:18>>*/ CamlinternalFormatBasics[3].call
+             (null, fmt$8, rest$20);
           /*<<scanf.ml:1405:40>>*/ fmt = fmt$9;
         }
         else{
@@ -30541,16 +30328,16 @@
           /*<<scanf.ml:1407:23>>*/ check_char(ib, 91);
          var
           fmt$11 =
-             /*<<scanf.ml:1408:18>>*/ caml_call2
-             (CamlinternalFormatBasics[3], fmt$10, rest$21);
+             /*<<scanf.ml:1408:18>>*/ CamlinternalFormatBasics[3].call
+             (null, fmt$10, rest$21);
           /*<<scanf.ml:1408:40>>*/ fmt = fmt$11;
         }
         break;
        case 19:
         var fmt_rest =  /*<<scanf.ml:1266:22>>*/ fmt[1];
          /*<<scanf.ml:1329:4>>*/ if(! readers)
-          /*<<scanf.ml:1334:8>>*/ return caml_call1
-                 (Stdlib[1], cst_scanf_missing_reader) /*<<scanf.ml:1418:7>>*/ ;
+          /*<<scanf.ml:1334:8>>*/ return Stdlib[1].call
+                 (null, cst_scanf_missing_reader) /*<<scanf.ml:1418:7>>*/ ;
         var
          readers_rest =  /*<<scanf.ml:1329:4>>*/ readers[2],
          reader = readers[1],
@@ -30613,8 +30400,8 @@
          rest$26 =  /*<<scanf.ml:1266:22>>*/ fmt[2],
          ign = fmt[1],
          fmt$12 =
-            /*<<scanf.ml:1411:32>>*/ caml_call2
-             (CamlinternalFormat[6], ign, rest$26)
+            /*<<scanf.ml:1411:32>>*/ CamlinternalFormat[6].call
+             (null, ign, rest$26)
             [1],
          match$3 =  /*<<scanf.ml:1412:16>>*/ make_scanf(ib, fmt$12, readers);
          /*<<scanf.ml:1412:42>>*/ if(! match$3)
@@ -30623,8 +30410,8 @@
         var arg_rest =  /*<<scanf.ml:1412:42>>*/ match$3[2];
          /*<<scanf.ml:1413:28>>*/ return arg_rest;
        default:
-         /*<<scanf.ml:1327:4>>*/ return caml_call1
-                (Stdlib[1], cst_scanf_bad_conversion_custo) /*<<scanf.ml:1418:7>>*/ ;
+         /*<<scanf.ml:1327:4>>*/ return Stdlib[1].call
+                (null, cst_scanf_bad_conversion_custo) /*<<scanf.ml:1418:7>>*/ ;
      }
     }
    }
@@ -30637,18 +30424,18 @@
        /*<<scanf.ml:1437:13>>*/ return [0, x$0, make_scanf(ib, fmt, readers)] /*<<scanf.ml:1437:38>>*/ ;
      }
       /*<<scanf.ml:1429:42>>*/ if(prec)
-       /*<<scanf.ml:1453:4>>*/ return caml_call1
-              (Stdlib[1], cst_scanf_bad_conversion) /*<<scanf.ml:1453:46>>*/ ;
+       /*<<scanf.ml:1453:4>>*/ return Stdlib[1].call
+              (null, cst_scanf_bad_conversion) /*<<scanf.ml:1453:46>>*/ ;
       /*<<scanf.ml:1431:12>>*/ caml_call3(scan, Stdlib[19], Stdlib[19], ib);
      var x =  /*<<scanf.ml:1432:12>>*/ caml_call1(token, ib);
       /*<<scanf.ml:1433:13>>*/ return [0, x, make_scanf(ib, fmt, readers)] /*<<scanf.ml:1433:38>>*/ ;
     }
      /*<<scanf.ml:1429:42>>*/ if(0 !== pad[0])
-      /*<<scanf.ml:1451:4>>*/ return caml_call1
-             (Stdlib[1], cst_scanf_bad_conversion$2) /*<<scanf.ml:1453:46>>*/ ;
+      /*<<scanf.ml:1451:4>>*/ return Stdlib[1].call
+             (null, cst_scanf_bad_conversion$2) /*<<scanf.ml:1453:46>>*/ ;
      /*<<scanf.ml:1429:42>>*/ if(! pad[1])
-      /*<<scanf.ml:1447:4>>*/ return caml_call1
-             (Stdlib[1], cst_scanf_bad_conversion$1) /*<<scanf.ml:1453:46>>*/ ;
+      /*<<scanf.ml:1447:4>>*/ return Stdlib[1].call
+             (null, cst_scanf_bad_conversion$1) /*<<scanf.ml:1453:46>>*/ ;
     var w =  /*<<scanf.ml:1429:42>>*/ pad[2];
     if(typeof prec !== "number"){
      var p$0 = prec[1];
@@ -30657,8 +30444,8 @@
       /*<<scanf.ml:1445:13>>*/ return [0, x$2, make_scanf(ib, fmt, readers)] /*<<scanf.ml:1445:38>>*/ ;
     }
      /*<<scanf.ml:1429:42>>*/ if(prec)
-      /*<<scanf.ml:1449:4>>*/ return caml_call1
-             (Stdlib[1], cst_scanf_bad_conversion$0) /*<<scanf.ml:1453:46>>*/ ;
+      /*<<scanf.ml:1449:4>>*/ return Stdlib[1].call
+             (null, cst_scanf_bad_conversion$0) /*<<scanf.ml:1453:46>>*/ ;
      /*<<scanf.ml:1439:12>>*/ caml_call3(scan, w, Stdlib[19], ib);
     var x$1 =  /*<<scanf.ml:1440:12>>*/ caml_call1(token, ib);
      /*<<scanf.ml:1441:13>>*/ return [0, x$1, make_scanf(ib, fmt, readers)] /*<<scanf.ml:1441:38>>*/ ;
@@ -30666,7 +30453,7 @@
    function kscanf_gen(ib, ef, af, param){
     var str =  /*<<scanf.ml:1458:15>>*/ param[2], fmt = param[1];
     function k(readers, f$1){
-      /*<<scanf.ml:222:23>>*/ caml_call1(Stdlib_Buffer[9], ib[8]);
+      /*<<scanf.ml:222:23>>*/ Stdlib_Buffer[9].call(null, ib[8]);
      try{
       var
        args$1 =  /*<<scanf.ml:1466:10>>*/ make_scanf(ib, fmt, readers),
@@ -30681,12 +30468,12 @@
        if(tag !== Stdlib[6]) throw caml_maybe_attach_backtrace(exc, 0);
        var
         msg = exc[2],
-        _v_ =  /*<<scanf.ml:1470:45>>*/ caml_call1(Stdlib_String[25], str),
-        _w_ = caml_call2(Stdlib[28], _v_, cst$0),
+        _v_ =  /*<<scanf.ml:1470:45>>*/ Stdlib_String[25].call(null, str),
+        _w_ = Stdlib[28].call(null, _v_, cst$0),
         _x_ =
-           /*<<scanf.ml:1470:27>>*/ caml_call2(Stdlib[28], cst_in_format, _w_),
-        _y_ =  /*<<scanf.ml:1470:20>>*/ caml_call2(Stdlib[28], msg, _x_);
-        /*<<scanf.ml:1470:71>>*/ return caml_call1(Stdlib[1], _y_) /*<<scanf.ml:1472:25>>*/ ;
+           /*<<scanf.ml:1470:27>>*/ Stdlib[28].call(null, cst_in_format, _w_),
+        _y_ =  /*<<scanf.ml:1470:20>>*/ Stdlib[28].call(null, msg, _x_);
+        /*<<scanf.ml:1470:71>>*/ return Stdlib[1].call(null, _y_) /*<<scanf.ml:1472:25>>*/ ;
       }
        /*<<scanf.ml:1468:8>>*/ return caml_call2(ef, ib, exc) /*<<scanf.ml:1472:25>>*/ ;
      }
@@ -30753,8 +30540,8 @@
      /*<<scanf.ml:1504:4>>*/ try{
      var
       _v_ =
-         /*<<scanf.ml:1505:10>>*/ caml_call2
-         (CamlinternalFormat[15], str, format),
+         /*<<scanf.ml:1505:10>>*/ CamlinternalFormat[15].call
+         (null, str, format),
       fmt = _v_;
     }
     catch(exn$0){
@@ -30772,20 +30559,20 @@
    }
    function format_from_string(s, fmt){
     var
-     _u_ =  /*<<scanf.ml:1517:24>>*/ caml_call1(Stdlib_String[25], s),
-     _v_ = caml_call2(Stdlib[28], _u_, cst$1);
+     _u_ =  /*<<scanf.ml:1517:24>>*/ Stdlib_String[25].call(null, s),
+     _v_ = Stdlib[28].call(null, _u_, cst$1);
      /*<<scanf.ml:1517:16>>*/ return  /*<<scanf.ml:1517:48>>*/ sscanf_format
-            ( /*<<scanf.ml:1517:16>>*/ caml_call2(Stdlib[28], cst$2, _v_),
+            ( /*<<scanf.ml:1517:16>>*/ Stdlib[28].call(null, cst$2, _v_),
              fmt,
              function(x){
                /*<<scanf.ml:1517:63>>*/ return x;
               /*<<scanf.ml:1517:64>>*/ }) /*<<scanf.ml:1517:65>>*/ ;
    }
    function unescaped(s){
-    var _u_ =  /*<<scanf.ml:1521:17>>*/ caml_call2(Stdlib[28], s, cst$3);
+    var _u_ =  /*<<scanf.ml:1521:17>>*/ Stdlib[28].call(null, s, cst$3);
      /*<<scanf.ml:1521:9>>*/ return  /*<<scanf.ml:1521:26>>*/ caml_call1
             (sscanf
-              ( /*<<scanf.ml:1521:9>>*/ caml_call2(Stdlib[28], cst$4, _u_),
+              ( /*<<scanf.ml:1521:9>>*/ Stdlib[28].call(null, cst$4, _u_),
                _t_),
              function(x){
                /*<<scanf.ml:1521:44>>*/ return x;
@@ -30882,11 +30669,6 @@
             ? 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,
@@ -30929,11 +30711,11 @@
     /*<<camlinternalOO.ml:78:15>>*/ }
    var
     compare =  /*<<?>>*/ caml_string_compare,
-    Vars = caml_call1(Stdlib_Map[1], [0, compare]),
+    Vars = Stdlib_Map[1].call(null, [0, compare]),
     compare$0 = caml_string_compare,
-    Meths = caml_call1(Stdlib_Map[1], [0, compare$0]),
+    Meths = Stdlib_Map[1].call(null, [0, compare$0]),
     compare$1 = runtime.caml_int_compare,
-    Labs = caml_call1(Stdlib_Map[1], [0, compare$1]),
+    Labs = Stdlib_Map[1].call(null, [0, compare$1]),
     dummy_table = [0, 0, [0, 0], Meths[1], Labs[1], 0, 0, Vars[1], 0],
     table_count = [0, 0],
     dummy_met =  /*<<camlinternalOO.ml:119:31>>*/ caml_obj_block(0, 0),
@@ -30999,8 +30781,8 @@
      var
       new_buck =
          /*<<camlinternalOO.ml:146:19>>*/ caml_array_make(new_size, dummy_met);
-      /*<<camlinternalOO.ml:147:4>>*/ caml_call5
-      (Stdlib_Array[9], array[2], 0, new_buck, 0, old_size);
+      /*<<camlinternalOO.ml:147:4>>*/ Stdlib_Array[9].call
+      (null, array[2], 0, new_buck, 0, old_size);
       /*<<camlinternalOO.ml:147:50>>*/ array[2] = new_buck;
      var _w_ = 0;
     }
@@ -31042,8 +30824,8 @@
     }
     /*<<camlinternalOO.ml:175:9>>*/ }
    function get_method_labels(table, names){
-     /*<<camlinternalOO.ml:178:36>>*/ return caml_call2
-            (Stdlib_Array[14],
+     /*<<camlinternalOO.ml:178:36>>*/ return Stdlib_Array[14].call
+            (null,
              function(_v_){
                /*<<camlinternalOO.ml:178:12>>*/ return get_method_label
                       (table, _v_);
@@ -31067,8 +30849,8 @@
      /*<<camlinternalOO.ml:188:2>>*/ try{
      var
       _v_ =
-         /*<<camlinternalOO.ml:188:6>>*/ caml_call2
-         (Stdlib_List[53], label, table[6]);
+         /*<<camlinternalOO.ml:188:6>>*/ Stdlib_List[53].call
+         (null, label, table[6]);
      return _v_;
     }
     catch(exn$0){
@@ -31083,8 +30865,9 @@
    function to_list(arr){
      /*<<camlinternalOO.ml:192:2>>*/ return 0 === arr
             ? 0
-            :  /*<<camlinternalOO.ml:192:37>>*/ caml_call1
-              (Stdlib_Array[10], arr) /*<<camlinternalOO.ml:192:54>>*/ ;
+            :  /*<<camlinternalOO.ml:192:37>>*/ Stdlib_Array
+               [10].call
+              (null, arr) /*<<camlinternalOO.ml:192:54>>*/ ;
    }
    function narrow(table, vars, virt_meths, concr_meths){
     var
@@ -31092,16 +30875,16 @@
      virt_meths$0 =  /*<<camlinternalOO.ml:196:19>>*/ to_list(virt_meths),
      concr_meths$0 =  /*<<camlinternalOO.ml:197:20>>*/ to_list(concr_meths),
      virt_meth_labs =
-        /*<<camlinternalOO.ml:198:23>>*/ caml_call2
-        (Stdlib_List[20],
+        /*<<camlinternalOO.ml:198:23>>*/ Stdlib_List[20].call
+        (null,
          function(_v_){
            /*<<camlinternalOO.ml:198:32>>*/ return get_method_label
                   (table, _v_);
          },
          virt_meths$0),
      concr_meth_labs =
-        /*<<camlinternalOO.ml:199:24>>*/ caml_call2
-        (Stdlib_List[20],
+        /*<<camlinternalOO.ml:199:24>>*/ Stdlib_List[20].call
+        (null,
          function(_v_){
            /*<<camlinternalOO.ml:199:33>>*/ return get_method_label
                   (table, _v_);
@@ -31115,8 +30898,8 @@
      caml_call3
       (Vars[24],
        function(lab, info, tvars){
-         /*<<camlinternalOO.ml:207:11>>*/ return caml_call2
-                 (Stdlib_List[37], lab, vars$0)
+         /*<<camlinternalOO.ml:207:11>>*/ return Stdlib_List[37].call
+                 (null, lab, vars$0)
                 ?  /*<<camlinternalOO.ml:207:34>>*/ caml_call3
                   (Vars[2], lab, info, tvars)
                 : tvars /*<<camlinternalOO.ml:207:68>>*/ ;
@@ -31126,8 +30909,8 @@
     var
      by_name =  /*<<camlinternalOO.ml:209:2>>*/ [0, Meths[1]],
      by_label =  /*<<camlinternalOO.ml:210:2>>*/ [0, Labs[1]];
-     /*<<camlinternalOO.ml:211:2>>*/ caml_call3
-     (Stdlib_List[28],
+     /*<<camlinternalOO.ml:211:2>>*/ Stdlib_List[28].call
+     (null,
       function(met, label){
         /*<<camlinternalOO.ml:213:18>>*/ by_name[1] =
         caml_call3(Meths[2], met, label, by_name[1]);
@@ -31150,8 +30933,8 @@
       },
       concr_meths$0,
       concr_meth_labs);
-     /*<<camlinternalOO.ml:219:2>>*/ caml_call3
-     (Stdlib_List[28],
+     /*<<camlinternalOO.ml:219:2>>*/ Stdlib_List[28].call
+     (null,
       function(met, label){
         /*<<camlinternalOO.ml:221:18>>*/ by_name[1] =
         caml_call3(Meths[2], met, label, by_name[1]);
@@ -31164,12 +30947,12 @@
      /*<<camlinternalOO.ml:223:29>>*/ table[3] = by_name[1];
      /*<<camlinternalOO.ml:225:2>>*/ table[4] = by_label[1];
      /*<<camlinternalOO.ml:227:5>>*/ table[6] =
-     caml_call3
-      (Stdlib_List[27],
+     Stdlib_List[27].call
+      (null,
        function(met, hm){
         var lab =  /*<<camlinternalOO.ml:228:7>>*/ met[1];
-         /*<<camlinternalOO.ml:229:13>>*/ return caml_call2
-                 (Stdlib_List[37], lab, virt_meth_labs)
+         /*<<camlinternalOO.ml:229:13>>*/ return Stdlib_List[37].call
+                 (null, lab, virt_meth_labs)
                 ? hm
                 : [0, met, hm] /*<<camlinternalOO.ml:229:62>>*/ ;
        },
@@ -31180,7 +30963,7 @@
    function widen(table){
     var
      match =
-        /*<<camlinternalOO.ml:235:4>>*/ caml_call1(Stdlib_List[6], table[5]),
+        /*<<camlinternalOO.ml:235:4>>*/ Stdlib_List[6].call(null, table[5]),
      vars =  /*<<camlinternalOO.ml:235:33>>*/ match[6],
      virt_meths = match[5],
      saved_vars = match[4],
@@ -31188,10 +30971,10 @@
      by_label = match[2],
      by_name = match[1];
      /*<<camlinternalOO.ml:237:27>>*/ table[5] =
-     caml_call1(Stdlib_List[7], table[5]);
+     Stdlib_List[7].call(null, table[5]);
      /*<<camlinternalOO.ml:239:5>>*/ table[7] =
-     caml_call3
-      (Stdlib_List[26],
+     Stdlib_List[26].call
+      (null,
        function(s, v){
         var
          _t_ =
@@ -31204,12 +30987,12 @@
      /*<<camlinternalOO.ml:242:2>>*/ table[3] = by_name;
      /*<<camlinternalOO.ml:243:2>>*/ table[4] = by_label;
      /*<<camlinternalOO.ml:245:5>>*/ table[6] =
-     caml_call3
-      (Stdlib_List[27],
+     Stdlib_List[27].call
+      (null,
        function(met, hm){
         var lab =  /*<<camlinternalOO.ml:246:7>>*/ met[1];
-         /*<<camlinternalOO.ml:247:13>>*/ return caml_call2
-                 (Stdlib_List[37], lab, virt_meths)
+         /*<<camlinternalOO.ml:247:13>>*/ return Stdlib_List[37].call
+                 (null, lab, virt_meths)
                 ? hm
                 : [0, met, hm] /*<<camlinternalOO.ml:247:58>>*/ ;
        },
@@ -31299,8 +31082,8 @@
     }
     /*<<camlinternalOO.ml:279:62>>*/ }
    function get_variables(table, names){
-     /*<<camlinternalOO.ml:282:32>>*/ return caml_call2
-            (Stdlib_Array[14],
+     /*<<camlinternalOO.ml:282:32>>*/ return Stdlib_Array[14].call
+            (null,
              function(_l_){
                /*<<camlinternalOO.ml:282:12>>*/ return get_variable
                       (table, _l_);
@@ -31316,11 +31099,11 @@
       /*<<camlinternalOO.ml:299:40>>*/ return new_table([0]) /*<<camlinternalOO.ml:309:7>>*/ ;
     var
      tags =
-        /*<<camlinternalOO.ml:301:13>>*/ caml_call2
-        (Stdlib_Array[14], public_method_label, public_methods),
+        /*<<camlinternalOO.ml:301:13>>*/ Stdlib_Array[14].call
+        (null, public_method_label, public_methods),
      table =  /*<<camlinternalOO.ml:302:14>>*/ new_table(tags);
-     /*<<camlinternalOO.ml:303:2>>*/ caml_call2
-     (Stdlib_Array[13],
+     /*<<camlinternalOO.ml:303:2>>*/ Stdlib_Array[13].call
+     (null,
       function(i, met){
        var lab =  /*<<camlinternalOO.ml:305:6>>*/ (i * 2 | 0) + 2 | 0;
         /*<<camlinternalOO.ml:306:32>>*/ table[3] =
@@ -31336,7 +31119,7 @@
      /*<<camlinternalOO.ml:312:2>>*/ inst_var_count[1] =
      (inst_var_count[1] + table[1] | 0) - 1 | 0;
      /*<<camlinternalOO.ml:313:24>>*/ table[8] =
-     caml_call1(Stdlib_List[10], table[8]);
+     Stdlib_List[10].call(null, table[8]);
     var _l_ =  /*<<camlinternalOO.ml:314:30>>*/ Stdlib_Sys[9];
     return  /*<<camlinternalOO.ml:314:47>>*/ resize
             (table,
@@ -31365,8 +31148,8 @@
      _i_ =  /*<<camlinternalOO.ml:326:7>>*/ to_array(concr_meths),
      _j_ =
         /*<<camlinternalOO.ml:324:5>>*/ [0,
-        caml_call2
-         (Stdlib_Array[14],
+        Stdlib_Array[14].call
+         (null,
           function(nm){
             /*<<camlinternalOO.ml:325:43>>*/ return  /*<<camlinternalOO.ml:325:68>>*/ get_method
                    (cla,
@@ -31379,14 +31162,14 @@
         /*<<camlinternalOO.ml:323:16>>*/ [0,
         [0, init],
         [0,
-         caml_call2
-          (Stdlib_Array[14],
+         Stdlib_Array[14].call
+          (null,
            function(_l_){
              /*<<camlinternalOO.ml:323:26>>*/ return get_variable(cla, _l_);
            },
            _k_),
          _j_]];
-     /*<<camlinternalOO.ml:323:60>>*/ return caml_call1(Stdlib_Array[5], _l_) /*<<camlinternalOO.ml:326:31>>*/ ;
+     /*<<camlinternalOO.ml:323:60>>*/ return Stdlib_Array[5].call(null, _l_) /*<<camlinternalOO.ml:326:31>>*/ ;
    }
    function make_class(pub_meths, class_init){
     var
@@ -31908,15 +31691,16 @@
               var _h_ =  /*<<camlinternalMod.ml:41:13>>*/ caml_obj_tag(l);
               if(250 === _h_) return l[1];
               if(246 !== _h_ && 244 !== _h_) return l;
-              return caml_call1(CamlinternalLazy[2], l);
+              return CamlinternalLazy[2].call(null, l);
              }]);
           var init =  /*<<camlinternalMod.ml:42:7>>*/ l;
           break;
          default:
           var
            init =
-              /*<<camlinternalMod.ml:44:48>>*/  /*<<camlinternalMod.ml:44:16>>*/ caml_call1
-              (CamlinternalOO[21], loc);
+              /*<<camlinternalMod.ml:44:48>>*/  /*<<camlinternalMod.ml:44:16>>*/ CamlinternalOO
+               [21].call
+              (null, loc);
        }
       else if(0 === shape[0])
        var
@@ -31942,8 +31726,8 @@
      var comps = shape[1];
       /*<<camlinternalMod.ml:62:5>>*/ return init_mod_block(loc, comps) /*<<camlinternalMod.ml:63:58>>*/ ;
     }
-     /*<<camlinternalMod.ml:63:9>>*/ return caml_call1
-            (Stdlib[2], cst_CamlinternalMod_init_mod_n) /*<<camlinternalMod.ml:63:58>>*/ ;
+     /*<<camlinternalMod.ml:63:9>>*/ return Stdlib[2].call
+            (null, cst_CamlinternalMod_init_mod_n) /*<<camlinternalMod.ml:63:58>>*/ ;
    }
    function update_mod_block(comps$0, modu, n){
      /*<<camlinternalMod.ml:81:10>>*/ if
@@ -32000,8 +31784,8 @@
      var comps = shape[1];
       /*<<camlinternalMod.ml:89:5>>*/ return update_mod_block(comps, o, n) /*<<camlinternalMod.ml:90:60>>*/ ;
     }
-     /*<<camlinternalMod.ml:90:9>>*/ return caml_call1
-            (Stdlib[2], cst_CamlinternalMod_update_mod) /*<<camlinternalMod.ml:90:60>>*/ ;
+     /*<<camlinternalMod.ml:90:9>>*/ return Stdlib[2].call
+            (null, cst_CamlinternalMod_update_mod) /*<<camlinternalMod.ml:90:60>>*/ ;
    }
    var CamlinternalMod =  /*<<?>>*/ [0, init_mod, update_mod];
    runtime.caml_register_global(8, CamlinternalMod, "CamlinternalMod");
@@ -32047,16 +31831,6 @@
             ? 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(),
     f$1 = cst_ensure_capacity$0,
@@ -32074,35 +31848,35 @@
     CamlinternalOO = global_data.CamlinternalOO,
     _a_ = [0, 0];
    function copy(a, dummy){
-    var _ae_ =  /*<<dynarray.ml:245:14>>*/ Stdlib_Obj[17];
-    if(caml_obj_tag(a) !== _ae_)
-      /*<<dynarray.ml:246:8>>*/ return caml_call1(Stdlib_Array[7], a) /*<<dynarray.ml:255:9>>*/ ;
+    var _af_ =  /*<<dynarray.ml:245:14>>*/ Stdlib_Obj[17];
+    if(caml_obj_tag(a) !== _af_)
+      /*<<dynarray.ml:246:8>>*/ return Stdlib_Array[7].call(null, a) /*<<dynarray.ml:255:9>>*/ ;
     var
      n =  /*<<dynarray.ml:247:11>>*/ a.length - 1,
      arr =  /*<<dynarray.ml:249:18>>*/ caml_array_make(n, dummy),
-     _ad_ =  /*<<dynarray.ml:250:8>>*/ n - 1 | 0,
-     _af_ = 0;
-    if(_ad_ >= 0){
-     var i = _af_;
+     _ae_ =  /*<<dynarray.ml:250:8>>*/ n - 1 | 0,
+     _ag_ = 0;
+    if(_ae_ >= 0){
+     var i = _ag_;
      for(;;){
       var v =  /*<<dynarray.ml:252:20>>*/ a[i + 1];
        /*<<dynarray.ml:251:10>>*/ arr[i + 1] = v;
-      var _ag_ =  /*<<dynarray.ml:252:43>>*/ i + 1 | 0;
-      if(_ad_ === i) break;
-      i = _ag_;
+      var _ah_ =  /*<<dynarray.ml:252:43>>*/ i + 1 | 0;
+      if(_ae_ === i) break;
+      i = _ah_;
      }
     }
      /*<<dynarray.ml:254:8>>*/ return arr;
     /*<<dynarray.ml:255:9>>*/ }
    function prefix(arr, n){
-     /*<<dynarray.ml:318:6>>*/ return caml_call3(Stdlib_Array[6], arr, 0, n) /*<<dynarray.ml:318:23>>*/ ;
+     /*<<dynarray.ml:318:6>>*/ return Stdlib_Array[6].call(null, arr, 0, n) /*<<dynarray.ml:318:23>>*/ ;
    }
    function extend(arr, length, dummy, new_capacity){
     var
      new_arr =
         /*<<dynarray.ml:323:20>>*/ caml_array_make(new_capacity, dummy);
-     /*<<dynarray.ml:324:6>>*/ caml_call5
-     (Stdlib_Array[9], arr, 0, new_arr, 0, length);
+     /*<<dynarray.ml:324:6>>*/ Stdlib_Array[9].call
+     (null, arr, 0, new_arr, 0, length);
      /*<<dynarray.ml:324:39>>*/ return new_arr;
     /*<<dynarray.ml:325:13>>*/ }
    var
@@ -32267,38 +32041,39 @@
     cst_x = "x";
    if(! _a_[1]){
     var
-     _b_ = caml_call1(CamlinternalOO[16], 0),
-     _c_ = caml_call2(CamlinternalOO[3], _b_, cst_x);
-    caml_call1(CamlinternalOO[17], _b_);
+     _b_ = CamlinternalOO[16].call(null, 0),
+     _c_ = CamlinternalOO[3].call(null, _b_, cst_x);
+    CamlinternalOO[17].call(null, _b_);
     _a_[1] =
-     function(_ad_){
-      var _ac_ =  /*<<?>>*/ caml_call2(CamlinternalOO[24], 0, _b_);
-      _ac_[_c_ + 1] = _ad_[2];
-      return _ac_;
+     function(_ae_){
+      var _ad_ =  /*<<?>>*/ CamlinternalOO[24].call(null, 0, _b_);
+      _ad_[_c_ + 1] = _ae_[2];
+      return _ad_;
      };
    }
    var dummy =  /*<<dynarray.ml:215:4>>*/ caml_call1(_a_[1], [0, 0, r]);
     /*<<dynarray.ml:218:4>>*/ r[1] = [0, dummy];
    function index_out_of_bounds(f, i, length){
      /*<<dynarray.ml:350:4>>*/ return 0 === length
-            ?  /*<<dynarray.ml:351:6>>*/ caml_call4
-              (Stdlib_Printf[10], Stdlib[1], _f_, f, i)
-            :  /*<<dynarray.ml:355:6>>*/ caml_call5
-              (Stdlib_Printf[10], Stdlib[1], _g_, f, i, length - 1 | 0) /*<<dynarray.ml:357:24>>*/ ;
+            ?  /*<<dynarray.ml:351:6>>*/ caml_call2
+              (Stdlib_Printf[10].call(null, Stdlib[1], _f_), f, i)
+            :  /*<<dynarray.ml:355:6>>*/ caml_call3
+              (Stdlib_Printf[10].call(null, Stdlib[1], _g_),
+               f,
+               i,
+               length - 1 | 0) /*<<dynarray.ml:357:24>>*/ ;
    }
    function negative_length_requested(f, n){
-     /*<<dynarray.ml:360:4>>*/ return caml_call4
-            (Stdlib_Printf[10], Stdlib[1], _h_, f, n) /*<<dynarray.ml:362:9>>*/ ;
+     /*<<dynarray.ml:360:4>>*/ return caml_call2
+            (Stdlib_Printf[10].call(null, Stdlib[1], _h_), f, n) /*<<dynarray.ml:362:9>>*/ ;
    }
    function negative_capacity_requested(f, n){
-     /*<<dynarray.ml:365:4>>*/ return caml_call4
-            (Stdlib_Printf[10], Stdlib[1], _i_, f, n) /*<<dynarray.ml:367:9>>*/ ;
+     /*<<dynarray.ml:365:4>>*/ return caml_call2
+            (Stdlib_Printf[10].call(null, Stdlib[1], _i_), f, n) /*<<dynarray.ml:367:9>>*/ ;
    }
    function missing_element(i, length){
-     /*<<dynarray.ml:384:4>>*/ return caml_call5
-            (Stdlib_Printf[10],
-             Stdlib[1],
-             _k_,
+     /*<<dynarray.ml:384:4>>*/ return caml_call3
+            (Stdlib_Printf[10].call(null, Stdlib[1], _k_),
              invalid_state_description,
              i,
              length) /*<<dynarray.ml:387:14>>*/ ;
@@ -32306,25 +32081,26 @@
    function check_same_length(f, param, expected){
     var
      length_a =  /*<<dynarray.ml:419:2>>*/ param[1],
-     _ac_ =  /*<<dynarray.ml:420:2>>*/ expected !== length_a ? 1 : 0;
-    return _ac_
-            ?  /*<<dynarray.ml:396:4>>*/ caml_call5
-              (Stdlib_Printf[10], Stdlib[1], _m_, f, expected, length_a)
-            : _ac_ /*<<dynarray.ml:422:41>>*/ ;
+     _ad_ =  /*<<dynarray.ml:420:2>>*/ expected !== length_a ? 1 : 0;
+    return _ad_
+            ?  /*<<dynarray.ml:396:4>>*/ caml_call3
+              (Stdlib_Printf[10].call(null, Stdlib[1], _m_),
+               f,
+               expected,
+               length_a)
+            : _ad_ /*<<dynarray.ml:422:41>>*/ ;
    }
    function check_valid_length(length, arr){
     var
      capacity =  /*<<dynarray.ml:429:2>>*/ arr.length - 1,
-     _ac_ =  /*<<dynarray.ml:430:2>>*/ capacity < length ? 1 : 0;
-    return _ac_
-            ?  /*<<dynarray.ml:390:4>>*/ caml_call5
-              (Stdlib_Printf[10],
-               Stdlib[1],
-               _l_,
+     _ad_ =  /*<<dynarray.ml:430:2>>*/ capacity < length ? 1 : 0;
+    return _ad_
+            ?  /*<<dynarray.ml:390:4>>*/ caml_call3
+              (Stdlib_Printf[10].call(null, Stdlib[1], _l_),
                invalid_state_description,
                length,
                capacity)
-            : _ac_ /*<<dynarray.ml:431:42>>*/ ;
+            : _ad_ /*<<dynarray.ml:431:42>>*/ ;
    }
    function unsafe_get(arr, dummy, i, length){
     var v =  /*<<dynarray.ml:438:10>>*/ arr[i + 1];
@@ -32338,15 +32114,15 @@
    function make(n, x){
      /*<<dynarray.ml:454:2>>*/ if(n < 0)
       /*<<dynarray.ml:454:16>>*/ negative_length_requested(cst_make, n);
-    var _ac_ =  /*<<dynarray.ml:236:14>>*/ Stdlib_Obj[16];
-    if(caml_obj_tag(x) !== _ac_)
+    var _ad_ =  /*<<dynarray.ml:236:14>>*/ Stdlib_Obj[16];
+    if(caml_obj_tag(x) !== _ad_)
      var
       arr$0 =
          /*<<dynarray.ml:237:31>>*/  /*<<dynarray.ml:237:8>>*/ caml_array_make
          (n, x);
     else{
      var arr =  /*<<dynarray.ml:239:18>>*/ caml_array_make(n, dummy);
-      /*<<dynarray.ml:240:8>>*/ caml_call4(Stdlib_Array[8], arr, 0, n, x);
+      /*<<dynarray.ml:240:8>>*/ Stdlib_Array[8].call(null, arr, 0, n, x);
      var arr$0 =  /*<<dynarray.ml:240:37>>*/ arr;
     }
      /*<<dynarray.ml:457:2>>*/ return [0, n, arr$0, dummy];
@@ -32356,16 +32132,16 @@
       /*<<dynarray.ml:464:16>>*/ negative_length_requested(cst_init, n);
     var
      arr =  /*<<dynarray.ml:263:16>>*/ caml_array_make(n, dummy),
-     _aa_ =  /*<<dynarray.ml:264:6>>*/ n - 1 | 0,
-     _ab_ = 0;
-    if(_aa_ >= 0){
-     var i = _ab_;
+     _ab_ =  /*<<dynarray.ml:264:6>>*/ n - 1 | 0,
+     _ac_ = 0;
+    if(_ab_ >= 0){
+     var i = _ac_;
      for(;;){
       var v =  /*<<dynarray.ml:265:39>>*/ caml_call1(f, i);
        /*<<dynarray.ml:265:8>>*/ arr[i + 1] = v;
-      var _ac_ =  /*<<dynarray.ml:265:45>>*/ i + 1 | 0;
-      if(_aa_ === i) break;
-      i = _ac_;
+      var _ad_ =  /*<<dynarray.ml:265:45>>*/ i + 1 | 0;
+      if(_ab_ === i) break;
+      i = _ad_;
      }
     }
      /*<<dynarray.ml:467:2>>*/ return [0, n, arr, dummy];
@@ -32411,8 +32187,8 @@
     var length =  /*<<dynarray.ml:501:2>>*/ a[1], arr = a[2], dummy = a[3];
      /*<<dynarray.ml:502:2>>*/ check_valid_length(length, arr);
      /*<<dynarray.ml:502:31>>*/ if(0 === length)
-      /*<<dynarray.ml:410:4>>*/ caml_call3
-      (Stdlib_Printf[10], Stdlib[1], _n_, f$0);
+      /*<<dynarray.ml:410:4>>*/ caml_call1
+      (Stdlib_Printf[10].call(null, Stdlib[1], _n_), f$0);
      /*<<dynarray.ml:506:2>>*/ return unsafe_get
             (arr, dummy, length - 1 | 0, length) /*<<dynarray.ml:506:47>>*/ ;
    }
@@ -32458,16 +32234,16 @@
    function remove_last(a){
     var
      last =  /*<<dynarray.ml:537:2>>*/ a[1] - 1 | 0,
-     _$_ =  /*<<dynarray.ml:538:2>>*/ 0 <= last ? 1 : 0;
-    if(_$_){
+     _aa_ =  /*<<dynarray.ml:538:2>>*/ 0 <= last ? 1 : 0;
+    if(_aa_){
       /*<<dynarray.ml:538:20>>*/ a[1] = last;
      var dummy =  /*<<dynarray.ml:540:4>>*/ a[3];
      caml_check_bound(a[2], last)[last + 1] = dummy;
-     var _aa_ =  /*<<dynarray.ml:540:42>>*/ 0;
+     var _ab_ =  /*<<dynarray.ml:540:42>>*/ 0;
     }
     else
-     var _aa_ =  /*<<dynarray.ml:538:2>>*/ _$_;
-    return _aa_;
+     var _ab_ =  /*<<dynarray.ml:538:2>>*/ _aa_;
+    return _ab_;
     /*<<dynarray.ml:541:5>>*/ }
    function truncate(a, n){
      /*<<dynarray.ml:544:2>>*/ if(n < 0)
@@ -32478,8 +32254,8 @@
             : (a
                [1]
               = n,
-               /*<<dynarray.ml:549:56>>*/ caml_call4
-               (Stdlib_Array[8], arr, n, length - n | 0, dummy)) /*<<dynarray.ml:550:5>>*/ ;
+               /*<<dynarray.ml:549:56>>*/ Stdlib_Array[8].call
+               (null, arr, n, length - n | 0, dummy)) /*<<dynarray.ml:550:5>>*/ ;
    }
    function clear(a){
      /*<<dynarray.ml:552:14>>*/ return truncate(a, 0) /*<<dynarray.ml:552:26>>*/ ;
@@ -32496,25 +32272,25 @@
              (cst_ensure_capacity, capacity_request) /*<<dynarray.ml:613:5>>*/ ;
      /*<<dynarray.ml:582:7>>*/ if(capacity_request <= cur_capacity)
       /*<<dynarray.ml:586:4>>*/ return 0;
-     /*<<dynarray.ml:587:7>>*/ if(Stdlib_Sys[13] < capacity_request)
-      /*<<dynarray.ml:370:4>>*/ caml_call5
-      (Stdlib_Printf[10],
-       Stdlib[1],
-       _j_,
+     /*<<dynarray.ml:587:7>>*/ if(Stdlib_Sys[13] < capacity_request){
+     var _Z_ =  /*<<dynarray.ml:370:4>>*/ Stdlib_Sys[13];
+     caml_call3
+      (Stdlib_Printf[10].call(null, Stdlib[1], _j_),
        f$1,
        capacity_request,
-       Stdlib_Sys[13]);
+       _Z_);
+    }
     var
      n =
         /*<<dynarray.ml:560:2>>*/ 512 < cur_capacity
         ? cur_capacity + (cur_capacity / 2 | 0) | 0
         : cur_capacity * 2 | 0,
-     _Z_ =  /*<<dynarray.ml:575:6>>*/ Stdlib_Sys[13],
-     ___ = caml_call2(Stdlib[17], 8, n),
-     _$_ =  /*<<dynarray.ml:575:16>>*/ caml_call2(Stdlib[16], ___, _Z_),
+     ___ =  /*<<dynarray.ml:575:6>>*/ Stdlib_Sys[13],
+     _$_ = Stdlib[17].call(null, 8, n),
+     _aa_ =  /*<<dynarray.ml:575:16>>*/ Stdlib[16].call(null, _$_, ___),
      new_capacity =
-        /*<<dynarray.ml:605:6>>*/ caml_call2
-        (Stdlib[17], _$_, capacity_request);
+        /*<<dynarray.ml:605:6>>*/ Stdlib[17].call
+        (null, _aa_, capacity_request);
      /*<<dynarray.ml:606:4>>*/ if(0 >= new_capacity)
      throw caml_maybe_attach_backtrace([0, Assert_failure, _q_], 1);
     var
@@ -32547,7 +32323,7 @@
      arr =  /*<<dynarray.ml:626:2>>*/ a[2],
      cur_capacity =  /*<<dynarray.ml:627:2>>*/ arr.length - 1;
      /*<<dynarray.ml:628:2>>*/ if(n < cur_capacity){
-      /*<<dynarray.ml:629:16>>*/ a[1] = caml_call2(Stdlib[16], a[1], n);
+      /*<<dynarray.ml:629:16>>*/ a[1] = Stdlib[16].call(null, a[1], n);
       /*<<dynarray.ml:630:13>>*/ a[2] = prefix(arr, n);
       /*<<dynarray.ml:630:37>>*/ return 0;
     }
@@ -32597,8 +32373,8 @@
              b) /*<<dynarray.ml:684:32>>*/ ;
    }
    function append_seq(a, seq){
-     /*<<dynarray.ml:687:2>>*/ return caml_call2
-            (Stdlib_Seq[4],
+     /*<<dynarray.ml:687:2>>*/ return Stdlib_Seq[4].call
+            (null,
              function(x){
                /*<<dynarray.ml:687:21>>*/ return add_last(a, x) /*<<dynarray.ml:687:33>>*/ ;
              },
@@ -32615,13 +32391,8 @@
       /*<<dynarray.ml:705:45>>*/ dst[1] = dst_pos + blit_length | 0;
     var dst_dummy =  /*<<dynarray.ml:710:2>>*/ dst[3], src_dummy = src[3];
      /*<<dynarray.ml:279:6>>*/ if(src_dummy === dst_dummy)
-      /*<<dynarray.ml:280:8>>*/ return caml_call5
-             (Stdlib_Array[9],
-              src_arr,
-              src_pos,
-              dst_arr,
-              dst_pos,
-              blit_length) /*<<dynarray.ml:713:20>>*/ ;
+      /*<<dynarray.ml:280:8>>*/ return Stdlib_Array[9].call
+             (null, src_arr, src_pos, dst_arr, dst_pos, blit_length) /*<<dynarray.ml:713:20>>*/ ;
     var _Q_ =  /*<<dynarray.ml:281:11>>*/ blit_length < 0 ? 1 : 0;
     if(_Q_)
      var _P_ = _Q_;
@@ -32670,16 +32441,14 @@
    function blit(src, src_pos, dst, dst_pos, len){
     var src_length =  /*<<dynarray.ml:489:22>>*/ src[1], dst_length = dst[1];
      /*<<dynarray.ml:718:2>>*/ if(len < 0)
-      /*<<dynarray.ml:719:4>>*/ caml_call3
-      (Stdlib_Printf[10], Stdlib[1], _r_, len);
+      /*<<dynarray.ml:719:4>>*/ caml_call1
+      (Stdlib_Printf[10].call(null, Stdlib[1], _r_), len);
     var
      _M_ =  /*<<dynarray.ml:722:2>>*/ src_pos < 0 ? 1 : 0,
      _N_ = _M_ || (src_length < (src_pos + len | 0) ? 1 : 0);
     if(_N_)
-      /*<<dynarray.ml:723:4>>*/ caml_call5
-      (Stdlib_Printf[10],
-       Stdlib[1],
-       _s_,
+      /*<<dynarray.ml:723:4>>*/ caml_call3
+      (Stdlib_Printf[10].call(null, Stdlib[1], _s_),
        src_pos,
        src_pos + len | 0,
        src_length);
@@ -32687,10 +32456,8 @@
      _O_ =  /*<<dynarray.ml:727:2>>*/ dst_pos < 0 ? 1 : 0,
      _P_ = _O_ || (dst_length < dst_pos ? 1 : 0);
     if(_P_)
-      /*<<dynarray.ml:728:4>>*/ caml_call5
-      (Stdlib_Printf[10],
-       Stdlib[1],
-       _t_,
+      /*<<dynarray.ml:728:4>>*/ caml_call3
+      (Stdlib_Printf[10].call(null, Stdlib[1], _t_),
        dst_pos,
        dst_pos + len | 0,
        dst_length);
@@ -32708,8 +32475,8 @@
      /*<<dynarray.ml:744:7>>*/ param[1] = length_a + length_b | 0;
     var _K_ =  /*<<dynarray.ml:270:14>>*/ Stdlib_Obj[17], src_pos = 0;
     if(caml_obj_tag(src) !== _K_)
-      /*<<dynarray.ml:271:8>>*/ caml_call5
-      (Stdlib_Array[9], src, src_pos, arr, length_a, length_b);
+      /*<<dynarray.ml:271:8>>*/ Stdlib_Array[9].call
+      (null, src, src_pos, arr, length_a, length_b);
     else{
      var _H_ =  /*<<dynarray.ml:272:11>>*/ length_b - 1 | 0, _L_ = 0;
      if(_H_ >= 0){
@@ -33170,8 +32937,8 @@
      /*<<dynarray.ml:1125:2>>*/ check_valid_length(length, arr);
     var
      res =
-        /*<<dynarray.ml:1126:12>>*/ caml_call2
-        (Stdlib_Array[1],
+        /*<<dynarray.ml:1126:12>>*/ Stdlib_Array[1].call
+        (null,
          length,
          function(i){
            /*<<dynarray.ml:1127:4>>*/ return unsafe_get(arr, dummy, i, length) /*<<dynarray.ml:1127:36>>*/ ;
@@ -33181,7 +32948,7 @@
     /*<<dynarray.ml:1130:5>>*/ }
    function of_list(li){
     var
-     a =  /*<<dynarray.ml:1133:10>>*/ caml_call1(Stdlib_Array[11], li),
+     a =  /*<<dynarray.ml:1133:10>>*/ Stdlib_Array[11].call(null, li),
      length =  /*<<dynarray.ml:1134:2>>*/ a.length - 1,
      _v_ =  /*<<dynarray.ml:258:14>>*/ Stdlib_Obj[17],
      arr =
@@ -33376,7 +33143,7 @@
       random =
          /*<<ephemeron.ml:107:15>>*/ opt
          ? opt[1]
-         :  /*<<ephemeron.ml:107:26>>*/ caml_call1(Stdlib_Hashtbl[17], 0),
+         :  /*<<ephemeron.ml:107:26>>*/ Stdlib_Hashtbl[17].call(null, 0),
       x =  /*<<ephemeron.ml:108:14>>*/ 16;
      for(;;){
        /*<<ephemeron.ml:101:6>>*/ if(initial_size <= x) break;
@@ -33391,7 +33158,7 @@
        var _H_ = prng[1];
       else{
        if(246 !== _G_ && 244 !== _G_){var _H_ = prng; break a;}
-       var _H_ = caml_call1(CamlinternalLazy[2], prng);
+       var _H_ = CamlinternalLazy[2].call(null, prng);
       }
       var
        seed =
@@ -33437,7 +33204,7 @@
      var
       _C_ =  /*<<ephemeron.ml:128:33>>*/ h[4],
       _D_ = h[3],
-      _E_ = caml_call1(Stdlib_Array[7], h[2]);
+      _E_ = Stdlib_Array[7].call(null, h[2]);
       /*<<ephemeron.ml:128:50>>*/ return [0, h[1], _E_, _D_, _C_];
      /*<<ephemeron.ml:128:52>>*/ }
     function key_index(h, hkey){
@@ -33753,18 +33520,18 @@
     function stats(h){
      var
       mbl =
-         /*<<ephemeron.ml:330:8>>*/ caml_call3
-         (Stdlib_Array[18],
+         /*<<ephemeron.ml:330:8>>*/ Stdlib_Array[18].call
+         (null,
           function(m, b){
            var _u_ =  /*<<ephemeron.ml:330:46>>*/ bucket_length(0, b);
-            /*<<ephemeron.ml:330:65>>*/ return caml_call2
-                   (Stdlib_Int[11], m, _u_);
+            /*<<ephemeron.ml:330:65>>*/ return Stdlib_Int[11].call
+                   (null, m, _u_);
           },
           0,
           h[2]),
       histo =  /*<<ephemeron.ml:331:18>>*/ caml_array_make(mbl + 1 | 0, 0);
-      /*<<ephemeron.ml:332:6>>*/ caml_call2
-      (Stdlib_Array[12],
+      /*<<ephemeron.ml:332:6>>*/ Stdlib_Array[12].call
+      (null,
        function(b){
         var l =  /*<<ephemeron.ml:334:19>>*/ bucket_length(0, b);
          /*<<ephemeron.ml:335:24>>*/ histo[l + 1] =
@@ -33798,18 +33565,18 @@
      var
       size =  /*<<ephemeron.ml:349:6>>*/ [0, 0],
       mbl =
-         /*<<ephemeron.ml:351:8>>*/ caml_call3
-         (Stdlib_Array[18],
+         /*<<ephemeron.ml:351:8>>*/ Stdlib_Array[18].call
+         (null,
           function(m, b){
            var _u_ =  /*<<ephemeron.ml:352:32>>*/ bucket_length_alive(0, b);
-            /*<<ephemeron.ml:352:57>>*/ return caml_call2
-                   (Stdlib_Int[11], m, _u_);
+            /*<<ephemeron.ml:352:57>>*/ return Stdlib_Int[11].call
+                   (null, m, _u_);
           },
           0,
           h[2]),
       histo =  /*<<ephemeron.ml:354:18>>*/ caml_array_make(mbl + 1 | 0, 0);
-      /*<<ephemeron.ml:355:6>>*/ caml_call2
-      (Stdlib_Array[12],
+      /*<<ephemeron.ml:355:6>>*/ Stdlib_Array[12].call
+      (null,
        function(b){
         var l =  /*<<ephemeron.ml:357:19>>*/ bucket_length_alive(0, b);
          /*<<ephemeron.ml:358:11>>*/ size[1] = size[1] + l | 0;
@@ -33825,8 +33592,8 @@
              histo];
      /*<<ephemeron.ml:364:34>>*/ }
     function add_seq(tbl, i){
-      /*<<ephemeron.ml:367:6>>*/ return caml_call2
-             (Stdlib_Seq[4],
+      /*<<ephemeron.ml:367:6>>*/ return Stdlib_Seq[4].call
+             (null,
               function(param){
                var v =  /*<<ephemeron.ml:367:15>>*/ param[2], k = param[1];
                 /*<<ephemeron.ml:367:29>>*/ return add(tbl, k, v) /*<<ephemeron.ml:367:41>>*/ ;
@@ -33834,8 +33601,8 @@
               i) /*<<ephemeron.ml:367:43>>*/ ;
     }
     function replace_seq(tbl, i){
-      /*<<ephemeron.ml:370:6>>*/ return caml_call2
-             (Stdlib_Seq[4],
+      /*<<ephemeron.ml:370:6>>*/ return Stdlib_Seq[4].call
+             (null,
               function(param){
                var v =  /*<<ephemeron.ml:370:15>>*/ param[2], k = param[1];
                 /*<<ephemeron.ml:370:29>>*/ return replace(tbl, k, v) /*<<ephemeron.ml:370:45>>*/ ;
@@ -34007,7 +33774,7 @@
        /*<<ephemeron.ml:470:16>>*/ return 0;
      var h =  /*<<ephemeron.ml:469:8>>*/ l[1], t = l[2];
       /*<<ephemeron.ml:471:22>>*/ if(test_key(k, h)){
-       /*<<ephemeron.ml:471:43>>*/ b[1] = caml_call2(Stdlib_List[13], acc, t);
+       /*<<ephemeron.ml:471:43>>*/ b[1] = Stdlib_List[13].call(null, acc, t);
        /*<<ephemeron.ml:471:64>>*/ return 0;
      }
      var
@@ -34020,8 +33787,8 @@
    function find(b, k){
     var
      match =
-        /*<<ephemeron.ml:477:12>>*/ caml_call2
-        (Stdlib_List[40],
+        /*<<ephemeron.ml:477:12>>*/ Stdlib_List[40].call
+        (null,
          function(_u_){ /*<<ephemeron.ml:477:26>>*/ return test_key(k, _u_);},
          b[1]);
      /*<<ephemeron.ml:477:41>>*/ if(! match)
@@ -34030,7 +33797,7 @@
      /*<<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>>*/ ;
+     /*<<ephemeron.ml:481:19>>*/ return Stdlib_List[1].call(null, b[1]) /*<<ephemeron.ml:481:33>>*/ ;
    }
    function clear(b){
      /*<<ephemeron.ml:482:18>>*/ b[1] = 0;
@@ -34225,7 +33992,7 @@
        /*<<ephemeron.ml:590:16>>*/ return 0;
      var h =  /*<<ephemeron.ml:589:8>>*/ l[1], t = l[2];
       /*<<ephemeron.ml:591:22>>*/ if(test_keys(k1, k2, h)){
-       /*<<ephemeron.ml:591:48>>*/ b[1] = caml_call2(Stdlib_List[13], acc, t);
+       /*<<ephemeron.ml:591:48>>*/ b[1] = Stdlib_List[13].call(null, acc, t);
        /*<<ephemeron.ml:591:69>>*/ return 0;
      }
      var
@@ -34238,8 +34005,8 @@
    function find$0(b, k1, k2){
     var
      match =
-        /*<<ephemeron.ml:597:12>>*/ caml_call2
-        (Stdlib_List[40],
+        /*<<ephemeron.ml:597:12>>*/ Stdlib_List[40].call
+        (null,
          function(_u_){
            /*<<ephemeron.ml:597:26>>*/ return test_keys(k1, k2, _u_);
          },
@@ -34250,7 +34017,7 @@
      /*<<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>>*/ ;
+     /*<<ephemeron.ml:601:19>>*/ return Stdlib_List[1].call(null, b[1]) /*<<ephemeron.ml:601:33>>*/ ;
    }
    function clear$0(b){
      /*<<ephemeron.ml:602:18>>*/ b[1] = 0;
@@ -34529,7 +34296,7 @@
        /*<<ephemeron.ml:724:16>>*/ return 0;
      var h =  /*<<ephemeron.ml:723:8>>*/ l[1], t = l[2];
       /*<<ephemeron.ml:725:22>>*/ if(test_keys$0(k, h)){
-       /*<<ephemeron.ml:725:44>>*/ b[1] = caml_call2(Stdlib_List[13], acc, t);
+       /*<<ephemeron.ml:725:44>>*/ b[1] = Stdlib_List[13].call(null, acc, t);
        /*<<ephemeron.ml:725:65>>*/ return 0;
      }
      var
@@ -34542,8 +34309,8 @@
    function find$1(b, k){
     var
      match =
-        /*<<ephemeron.ml:731:12>>*/ caml_call2
-        (Stdlib_List[40],
+        /*<<ephemeron.ml:731:12>>*/ Stdlib_List[40].call
+        (null,
          function(_c_){
            /*<<ephemeron.ml:731:26>>*/ return test_keys$0(k, _c_);
          },
@@ -34554,7 +34321,7 @@
      /*<<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>>*/ ;
+     /*<<ephemeron.ml:735:19>>*/ return Stdlib_List[1].call(null, b[1]) /*<<ephemeron.ml:735:33>>*/ ;
    }
    function clear$1(b){
      /*<<ephemeron.ml:736:18>>*/ b[1] = 0;
@@ -34630,11 +34397,6 @@
             ? 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,
@@ -34686,8 +34448,8 @@
      n = n$3;
     for(;;){
       /*<<filename.ml:38:4>>*/ if(0 > n)
-       /*<<filename.ml:38:18>>*/ return caml_call3
-              (Stdlib_String[16], name, 0, 1) /*<<filename.ml:48:40>>*/ ;
+       /*<<filename.ml:38:18>>*/ return Stdlib_String[16].call
+              (null, name, 0, 1) /*<<filename.ml:48:40>>*/ ;
       /*<<filename.ml:39:12>>*/ if(! caml_call2(is_dir_sep, name, n)) break;
      var n$0 =  /*<<filename.ml:39:35>>*/ n - 1 | 0;
      n = n$0;
@@ -34695,11 +34457,11 @@
     var p =  /*<<filename.ml:40:9>>*/ n + 1 | 0, n$1 = n;
     for(;;){
       /*<<filename.ml:42:4>>*/ if(0 > n$1)
-       /*<<filename.ml:42:18>>*/ return caml_call3
-              (Stdlib_String[16], name, 0, p) /*<<filename.ml:48:40>>*/ ;
+       /*<<filename.ml:42:18>>*/ return Stdlib_String[16].call
+              (null, name, 0, p) /*<<filename.ml:48:40>>*/ ;
       /*<<filename.ml:43:12>>*/ if(caml_call2(is_dir_sep, name, n$1))
-       /*<<filename.ml:43:35>>*/ return caml_call3
-              (Stdlib_String[16], name, n$1 + 1 | 0, (p - n$1 | 0) - 1 | 0) /*<<filename.ml:48:40>>*/ ;
+       /*<<filename.ml:43:35>>*/ return Stdlib_String[16].call
+              (null, name, n$1 + 1 | 0, (p - n$1 | 0) - 1 | 0) /*<<filename.ml:48:40>>*/ ;
      var n$2 =  /*<<filename.ml:44:9>>*/ n$1 - 1 | 0;
      n$1 = n$2;
     }
@@ -34712,8 +34474,8 @@
      n = n$5;
     for(;;){
       /*<<filename.ml:56:4>>*/ if(0 > n)
-       /*<<filename.ml:56:18>>*/ return caml_call3
-              (Stdlib_String[16], name, 0, 1) /*<<filename.ml:70:44>>*/ ;
+       /*<<filename.ml:56:18>>*/ return Stdlib_String[16].call
+              (null, name, 0, 1) /*<<filename.ml:70:44>>*/ ;
       /*<<filename.ml:57:12>>*/ if(! caml_call2(is_dir_sep, name, n)){
       var n$1 =  /*<<filename.ml:57:29>>*/ n;
       break;
@@ -34733,11 +34495,11 @@
     }
      /*<<filename.ml:70:7>>*/ for(;;){
       /*<<filename.ml:64:4>>*/ if(0 > n$3)
-       /*<<filename.ml:64:18>>*/ return caml_call3
-              (Stdlib_String[16], name, 0, 1) /*<<filename.ml:70:44>>*/ ;
+       /*<<filename.ml:64:18>>*/ return Stdlib_String[16].call
+              (null, name, 0, 1) /*<<filename.ml:70:44>>*/ ;
       /*<<filename.ml:65:12>>*/ if(! caml_call2(is_dir_sep, name, n$3))
-       /*<<filename.ml:66:9>>*/ return caml_call3
-              (Stdlib_String[16], name, 0, n$3 + 1 | 0) /*<<filename.ml:70:44>>*/ ;
+       /*<<filename.ml:66:9>>*/ return Stdlib_String[16].call
+              (null, name, 0, n$3 + 1 | 0) /*<<filename.ml:70:44>>*/ ;
      var n$4 =  /*<<filename.ml:65:35>>*/ n$3 - 1 | 0;
      n$3 = n$4;
     }
@@ -34761,7 +34523,7 @@
       _aa_ =
         _ab_
         ||
-         ( /*<<filename.ml:100:31>>*/ caml_call3(Stdlib_String[16], n, 0, 2)
+         ( /*<<filename.ml:100:31>>*/ Stdlib_String[16].call(null, n, 0, 2)
            !== cst$27
            ? 1
            : 0);
@@ -34771,7 +34533,7 @@
        ___ =
          _ac_
          ||
-          ( /*<<filename.ml:101:31>>*/ caml_call3(Stdlib_String[16], n, 0, 3)
+          ( /*<<filename.ml:101:31>>*/ Stdlib_String[16].call(null, n, 0, 3)
             !== cst$28
             ? 1
             : 0);
@@ -34783,8 +34545,7 @@
     return ___;
     /*<<filename.ml:101:57>>*/ }
    function check_suffix(name, suff){
-     /*<<filename.ml:103:4>>*/ return caml_call2
-            (Stdlib_String[12], suff, name) /*<<filename.ml:103:38>>*/ ;
+     /*<<filename.ml:103:4>>*/ return Stdlib_String[12].call(null, suff, name) /*<<filename.ml:103:38>>*/ ;
    }
    function chop_suffix_opt(suffix, filename){
     var
@@ -34794,12 +34555,12 @@
       /*<<filename.ml:114:6>>*/ return 0;
     var
      r =
-        /*<<filename.ml:108:14>>*/ caml_call3
-        (Stdlib_String[16], filename, len_f - len_s | 0, len_s);
+        /*<<filename.ml:108:14>>*/ Stdlib_String[16].call
+        (null, filename, len_f - len_s | 0, len_s);
      /*<<filename.ml:109:19>>*/ return r === suffix
             ? [0,
-               /*<<filename.ml:110:13>>*/ caml_call3
-               (Stdlib_String[16], filename, 0, len_f - len_s | 0)]
+               /*<<filename.ml:110:13>>*/ Stdlib_String[16].call
+               (null, filename, 0, len_f - len_s | 0)]
             : 0 /*<<filename.ml:114:10>>*/ ;
    }
    var
@@ -34830,25 +34591,25 @@
    function quote(s){
     var
      l =  /*<<filename.ml:17:2>>*/ caml_ml_string_length(s),
-     b =  /*<<filename.ml:18:10>>*/ caml_call1(Stdlib_Buffer[1], l + 20 | 0);
-     /*<<filename.ml:19:2>>*/ caml_call2(Stdlib_Buffer[12], b, 39);
+     b =  /*<<filename.ml:18:10>>*/ Stdlib_Buffer[1].call(null, l + 20 | 0);
+     /*<<filename.ml:19:2>>*/ Stdlib_Buffer[12].call(null, b, 39);
     var _X_ =  /*<<filename.ml:19:24>>*/ l - 1 | 0, _Y_ = 0;
     if(_X_ >= 0){
      var i = _Y_;
      for(;;){
        /*<<filename.ml:21:7>>*/ if(39 === caml_string_get(s, i))
-        /*<<filename.ml:22:9>>*/ caml_call2(Stdlib_Buffer[16], b, quotequote);
+        /*<<filename.ml:22:9>>*/ Stdlib_Buffer[16].call(null, b, quotequote);
       else{
        var ___ =  /*<<filename.ml:23:28>>*/ caml_string_get(s, i);
-        /*<<filename.ml:23:9>>*/ caml_call2(Stdlib_Buffer[12], b, ___);
+        /*<<filename.ml:23:9>>*/ Stdlib_Buffer[12].call(null, b, ___);
       }
       var _Z_ =  /*<<filename.ml:21:12>>*/ i + 1 | 0;
       if(_X_ === i) break;
       i = _Z_;
      }
     }
-     /*<<filename.ml:25:2>>*/ caml_call2(Stdlib_Buffer[12], b, 39);
-     /*<<filename.ml:25:24>>*/ return caml_call1(Stdlib_Buffer[2], b);
+     /*<<filename.ml:25:2>>*/ Stdlib_Buffer[12].call(null, b, 39);
+     /*<<filename.ml:25:24>>*/ return Stdlib_Buffer[2].call(null, b);
    }
    function quote_command(cmd, stdin, stdout, stderr, args){
      /*<<filename.ml:120:4>>*/ if(stderr){
@@ -34859,8 +34620,8 @@
       var
        _X_ =  /*<<filename.ml:125:61>>*/ quote(f),
        _O_ =
-          /*<<filename.ml:125:68>>*/  /*<<filename.ml:125:53>>*/ caml_call2
-          (Stdlib[28], cst_2, _X_);
+          /*<<filename.ml:125:68>>*/  /*<<filename.ml:125:53>>*/ Stdlib[28].call
+          (null, cst_2, _X_);
     }
     else
      var _O_ =  /*<<filename.ml:120:4>>*/ cst$4;
@@ -34869,27 +34630,27 @@
       f$0 = stdout[1],
       _R_ =  /*<<filename.ml:122:55>>*/ quote(f$0),
       _P_ =
-         /*<<filename.ml:122:62>>*/  /*<<filename.ml:122:48>>*/ caml_call2
-         (Stdlib[28], cst, _R_);
+         /*<<filename.ml:122:62>>*/  /*<<filename.ml:122:48>>*/ Stdlib[28].call
+         (null, cst, _R_);
     else
      var _P_ =  /*<<filename.ml:120:4>>*/ cst$3;
-    var _S_ =  /*<<filename.ml:122:6>>*/ caml_call2(Stdlib[28], _P_, _O_);
+    var _S_ =  /*<<filename.ml:122:6>>*/ Stdlib[28].call(null, _P_, _O_);
      /*<<filename.ml:125:69>>*/ if(stdin)
      var
       f$1 = stdin[1],
       _T_ =  /*<<filename.ml:121:55>>*/ quote(f$1),
       _Q_ =
-         /*<<filename.ml:121:62>>*/  /*<<filename.ml:121:48>>*/ caml_call2
-         (Stdlib[28], cst$0, _T_);
+         /*<<filename.ml:121:62>>*/  /*<<filename.ml:121:48>>*/ Stdlib[28].call
+         (null, cst$0, _T_);
     else
      var _Q_ =  /*<<filename.ml:125:69>>*/ cst$2;
     var
-     _U_ =  /*<<filename.ml:121:6>>*/ caml_call2(Stdlib[28], _Q_, _S_),
+     _U_ =  /*<<filename.ml:121:6>>*/ Stdlib[28].call(null, _Q_, _S_),
      _V_ =
-        /*<<filename.ml:120:22>>*/ caml_call2
-        (Stdlib_List[20], quote, [0, cmd, args]),
-     _W_ =  /*<<filename.ml:120:4>>*/ caml_call2(Stdlib_String[7], cst$1, _V_);
-     /*<<filename.ml:120:52>>*/ return caml_call2(Stdlib[28], _W_, _U_) /*<<filename.ml:125:69>>*/ ;
+        /*<<filename.ml:120:22>>*/ Stdlib_List[20].call
+        (null, quote, [0, cmd, args]),
+     _W_ =  /*<<filename.ml:120:4>>*/ Stdlib_String[7].call(null, cst$1, _V_);
+     /*<<filename.ml:120:52>>*/ return Stdlib[28].call(null, _W_, _U_) /*<<filename.ml:125:69>>*/ ;
    }
    function basename(_O_){
      /*<<filename.ml:126:17>>*/ return generic_basename
@@ -34959,7 +34720,7 @@
       _B_ =
         _E_
         ||
-         ( /*<<filename.ml:142:31>>*/ caml_call3(Stdlib_String[16], n, 0, 2)
+         ( /*<<filename.ml:142:31>>*/ Stdlib_String[16].call(null, n, 0, 2)
            !== cst$27
            ? 1
            : 0);
@@ -34969,7 +34730,7 @@
        _C_ =
          _F_
          ||
-          ( /*<<filename.ml:143:31>>*/ caml_call3(Stdlib_String[16], n, 0, 2)
+          ( /*<<filename.ml:143:31>>*/ Stdlib_String[16].call(null, n, 0, 2)
             !== ".\\"
             ? 1
             : 0);
@@ -34979,7 +34740,7 @@
         _D_ =
           _G_
           ||
-           ( /*<<filename.ml:144:31>>*/ caml_call3(Stdlib_String[16], n, 0, 3)
+           ( /*<<filename.ml:144:31>>*/ Stdlib_String[16].call(null, n, 0, 3)
              !== cst$28
              ? 1
              : 0);
@@ -34989,8 +34750,7 @@
          _z_ =
            _H_
            ||
-            ( /*<<filename.ml:145:31>>*/ caml_call3
-               (Stdlib_String[16], n, 0, 3)
+            ( /*<<filename.ml:145:31>>*/ Stdlib_String[16].call(null, n, 0, 3)
               !== "..\\"
               ? 1
               : 0);
@@ -35017,17 +34777,18 @@
     if(_x_)
      var
       s =
-         /*<<filename.ml:148:12>>*/ caml_call3
-         (Stdlib_String[16],
+         /*<<filename.ml:148:12>>*/ Stdlib_String[16].call
+         (null,
           name,
            /*<<filename.ml:147:3>>*/ caml_ml_string_length(name)
           - caml_ml_string_length(suff)
           | 0,
           caml_ml_string_length(suff)),
-      _z_ =  /*<<filename.ml:150:31>>*/ caml_call1(Stdlib_String[27], suff),
+      _z_ =  /*<<filename.ml:150:31>>*/ Stdlib_String[27].call(null, suff),
       _y_ =
-         /*<<filename.ml:150:58>>*/  /*<<filename.ml:150:4>>*/ caml_call1
-          (Stdlib_String[27], s)
+         /*<<filename.ml:150:58>>*/  /*<<filename.ml:150:4>>*/ Stdlib_String
+           [27].call
+          (null, s)
          === _z_
          ? 1
          : 0;
@@ -35043,13 +34804,13 @@
       /*<<filename.ml:161:6>>*/ return 0;
     var
      r =
-        /*<<filename.ml:155:14>>*/ caml_call3
-        (Stdlib_String[16], filename, len_f - len_s | 0, len_s),
-     _x_ =  /*<<filename.ml:156:36>>*/ caml_call1(Stdlib_String[27], suffix);
-     /*<<filename.ml:156:9>>*/ return caml_call1(Stdlib_String[27], r) === _x_
+        /*<<filename.ml:155:14>>*/ Stdlib_String[16].call
+        (null, filename, len_f - len_s | 0, len_s),
+     _x_ =  /*<<filename.ml:156:36>>*/ Stdlib_String[27].call(null, suffix);
+     /*<<filename.ml:156:9>>*/ return Stdlib_String[27].call(null, r) === _x_
             ? [0,
-               /*<<filename.ml:157:13>>*/ caml_call3
-               (Stdlib_String[16], filename, 0, len_f - len_s | 0)]
+               /*<<filename.ml:157:13>>*/ Stdlib_String[16].call
+               (null, filename, 0, len_f - len_s | 0)]
             : 0 /*<<filename.ml:161:10>>*/ ;
    }
     /*<<filename.ml:127:59>>*/ try{
@@ -35065,13 +34826,13 @@
    function quote$0(s){
     var
      l =  /*<<filename.ml:167:4>>*/ caml_ml_string_length(s),
-     b =  /*<<filename.ml:168:12>>*/ caml_call1(Stdlib_Buffer[1], l + 20 | 0);
-     /*<<filename.ml:169:4>>*/ caml_call2(Stdlib_Buffer[12], b, 34);
+     b =  /*<<filename.ml:168:12>>*/ Stdlib_Buffer[1].call(null, l + 20 | 0);
+     /*<<filename.ml:169:4>>*/ Stdlib_Buffer[12].call(null, b, 34);
     function loop$0(counter, i$1){
      var i =  /*<<filename.ml:171:6>>*/ i$1;
      for(;;){
       if(i === l)
-        /*<<filename.ml:171:20>>*/ return caml_call2(Stdlib_Buffer[12], b, 34) /*<<filename.ml:175:48>>*/ ;
+        /*<<filename.ml:171:20>>*/ return Stdlib_Buffer[12].call(null, b, 34) /*<<filename.ml:175:48>>*/ ;
       var c =  /*<<filename.ml:172:12>>*/ caml_string_get(s, i);
        /*<<filename.ml:172:17>>*/ if(34 === c){
        var _w_ =  /*<<filename.ml:173:16>>*/ 0;
@@ -35087,7 +34848,7 @@
        var counter$0 =  /*<<filename.ml:174:16>>*/ counter + 1 | 0;
        return loop_bs(counter$0, _x_, i) /*<<filename.ml:175:48>>*/ ;
       }
-       /*<<filename.ml:175:16>>*/ caml_call2(Stdlib_Buffer[12], b, c);
+       /*<<filename.ml:175:16>>*/ Stdlib_Buffer[12].call(null, b, c);
       var i$0 =  /*<<filename.ml:175:35>>*/ i + 1 | 0;
       i = i$0;
      }
@@ -35100,13 +34861,13 @@
      var n =  /*<<filename.ml:177:6>>*/ n$1, i = i$1;
      for(;;){
       if(i === l){
-        /*<<filename.ml:178:8>>*/ caml_call2(Stdlib_Buffer[12], b, 34);
+        /*<<filename.ml:178:8>>*/ Stdlib_Buffer[12].call(null, b, 34);
         /*<<filename.ml:178:30>>*/ return add_bs(n) /*<<filename.ml:185:9>>*/ ;
       }
       var match =  /*<<filename.ml:181:14>>*/ caml_string_get(s, i);
        /*<<filename.ml:181:19>>*/ if(34 === match){
         /*<<filename.ml:182:18>>*/ add_bs((2 * n | 0) + 1 | 0);
-        /*<<filename.ml:182:34>>*/ caml_call2(Stdlib_Buffer[12], b, 34);
+        /*<<filename.ml:182:34>>*/ Stdlib_Buffer[12].call(null, b, 34);
        var _w_ =  /*<<filename.ml:182:56>>*/ i + 1 | 0;
        if(counter >= 50)
         return caml_trampoline_return(loop$0, [0, _w_]) /*<<filename.ml:185:9>>*/ ;
@@ -35130,7 +34891,7 @@
      if(n >= 1){
       var j = _v_;
       for(;;){
-        /*<<filename.ml:186:38>>*/ caml_call2(Stdlib_Buffer[12], b, 92);
+        /*<<filename.ml:186:38>>*/ Stdlib_Buffer[12].call(null, b, 92);
        var _w_ =  /*<<filename.ml:186:60>>*/ j + 1 | 0;
        if(n === j) break;
        j = _w_;
@@ -35138,14 +34899,15 @@
      }
      /*<<filename.ml:186:66>>*/ }
      /*<<filename.ml:188:4>>*/ loop(0);
-     /*<<filename.ml:188:10>>*/ return caml_call1(Stdlib_Buffer[2], b) /*<<filename.ml:189:21>>*/ ;
+     /*<<filename.ml:188:10>>*/ return Stdlib_Buffer[2].call(null, b) /*<<filename.ml:189:21>>*/ ;
    }
    function quote_cmd_filename(f){
     var
      f$0 =
-        /*<<filename.ml:225:9>>*/ caml_call2(Stdlib_String[15], f, 47)
-        ?  /*<<filename.ml:226:8>>*/ caml_call2
-          (Stdlib_String[18],
+        /*<<filename.ml:225:9>>*/ Stdlib_String[15].call(null, f, 47)
+        ?  /*<<filename.ml:226:8>>*/ Stdlib_String
+           [18].call
+          (null,
            function(c){
              /*<<filename.ml:226:19>>*/ return 47 === c ? 92 : c /*<<filename.ml:226:50>>*/ ;
            },
@@ -35153,23 +34915,24 @@
         : f;
      /*<<filename.ml:229:7>>*/ if
      (!
-      caml_call2
-       (Stdlib_String[23],
+      Stdlib_String[23].call
+       (null,
         function(param){
           /*<<filename.ml:229:21>>*/ if(34 !== param && 37 !== param)
            /*<<filename.ml:229:57>>*/ return 0;
           /*<<filename.ml:229:45>>*/ return 1;
          /*<<filename.ml:229:63>>*/ },
         f$0))
-      /*<<filename.ml:231:12>>*/ return caml_call2(Stdlib_String[15], f$0, 32)
-             ?  /*<<filename.ml:232:6>>*/ caml_call2
-               (Stdlib_String[7], cst$7, [0, cst$6, [0, f$0, _a_]])
+      /*<<filename.ml:231:12>>*/ return Stdlib_String[15].call(null, f$0, 32)
+             ?  /*<<filename.ml:232:6>>*/ Stdlib_String
+                [7].call
+               (null, cst$7, [0, cst$6, [0, f$0, _a_]])
              : f$0 /*<<filename.ml:234:7>>*/ ;
     var
      _v_ =
-        /*<<filename.ml:230:15>>*/ caml_call2
-        (Stdlib[28], cst_Filename_quote_command_bad, f$0);
-     /*<<filename.ml:230:61>>*/ return caml_call1(Stdlib[2], _v_) /*<<filename.ml:234:7>>*/ ;
+        /*<<filename.ml:230:15>>*/ Stdlib[28].call
+        (null, cst_Filename_quote_command_bad, f$0);
+     /*<<filename.ml:230:61>>*/ return Stdlib[2].call(null, _v_) /*<<filename.ml:234:7>>*/ ;
    }
    function quote_command$0(cmd, stdin, stdout, stderr, args){
      /*<<filename.ml:239:4>>*/ if(stderr){
@@ -35180,8 +34943,8 @@
       var
        _v_ =  /*<<filename.ml:249:53>>*/ quote_cmd_filename(f),
        _l_ =
-          /*<<filename.ml:249:73>>*/  /*<<filename.ml:249:45>>*/ caml_call2
-          (Stdlib[28], cst_2$0, _v_);
+          /*<<filename.ml:249:73>>*/  /*<<filename.ml:249:45>>*/ Stdlib[28].call
+          (null, cst_2$0, _v_);
     }
     else
      var _l_ =  /*<<filename.ml:239:4>>*/ cst$16;
@@ -35191,8 +34954,8 @@
       f$0 = stdout[1],
       _p_ =  /*<<filename.ml:245:55>>*/ quote_cmd_filename(f$0),
       _m_ =
-         /*<<filename.ml:245:75>>*/  /*<<filename.ml:245:48>>*/ caml_call2
-         (Stdlib[28], cst$8, _p_);
+         /*<<filename.ml:245:75>>*/  /*<<filename.ml:245:48>>*/ Stdlib[28].call
+         (null, cst$8, _p_);
     else
      var _m_ =  /*<<filename.ml:239:4>>*/ cst$15;
     var _q_ = [0, _m_, _o_];
@@ -35201,20 +34964,19 @@
       f$1 = stdin[1],
       _r_ =  /*<<filename.ml:244:55>>*/ quote_cmd_filename(f$1),
       _n_ =
-         /*<<filename.ml:244:75>>*/  /*<<filename.ml:244:48>>*/ caml_call2
-         (Stdlib[28], cst$9, _r_);
+         /*<<filename.ml:244:75>>*/  /*<<filename.ml:244:48>>*/ Stdlib[28].call
+         (null, cst$9, _r_);
     else
      var _n_ =  /*<<filename.ml:239:4>>*/ cst$14;
     var
      _s_ =
-        /*<<filename.ml:243:35>>*/ caml_call2(Stdlib_List[20], quote$0, args),
-     s =  /*<<filename.ml:243:16>>*/ caml_call2(Stdlib_String[7], cst$10, _s_),
+        /*<<filename.ml:243:35>>*/ Stdlib_List[20].call(null, quote$0, args),
+     s =  /*<<filename.ml:243:16>>*/ Stdlib_String[7].call(null, cst$10, _s_),
      b =
-        /*<<filename.ml:211:4>>*/  /*<<filename.ml:211:12>>*/ caml_call1
-        (Stdlib_Buffer[1],
-          /*<<filename.ml:211:4>>*/ caml_ml_string_length(s) + 20 | 0);
-     /*<<filename.ml:212:4>>*/ caml_call2
-     (Stdlib_String[30],
+        /*<<filename.ml:211:4>>*/  /*<<filename.ml:211:12>>*/ Stdlib_Buffer[1].call
+        (null,  /*<<filename.ml:211:4>>*/ caml_ml_string_length(s) + 20 | 0);
+     /*<<filename.ml:212:4>>*/ Stdlib_String[30].call
+     (null,
       function(c){
        a:
        {
@@ -35234,23 +34996,23 @@
           switch(c - 33 | 0){case 2:case 3:case 6: break a;
           }
          }
-         /*<<filename.ml:216:12>>*/ caml_call2(Stdlib_Buffer[12], b, 94);
-         /*<<filename.ml:216:33>>*/ return caml_call2(Stdlib_Buffer[12], b, c) /*<<filename.ml:218:31>>*/ ;
+         /*<<filename.ml:216:12>>*/ Stdlib_Buffer[12].call(null, b, 94);
+         /*<<filename.ml:216:33>>*/ return Stdlib_Buffer[12].call(null, b, c) /*<<filename.ml:218:31>>*/ ;
        }
-        /*<<filename.ml:218:12>>*/ return caml_call2(Stdlib_Buffer[12], b, c) /*<<filename.ml:218:31>>*/ ;
+        /*<<filename.ml:218:12>>*/ return Stdlib_Buffer[12].call(null, b, c) /*<<filename.ml:218:31>>*/ ;
       },
       s);
     var
      _t_ =
         /*<<filename.ml:219:7>>*/ [0,
         cst$11,
-        [0, caml_call1(Stdlib_Buffer[2], b), [0, _n_, _q_]]],
+        [0, Stdlib_Buffer[2].call(null, b), [0, _n_, _q_]]],
      _u_ =
         /*<<filename.ml:241:6>>*/ [0,
         cst$12,
         [0, quote_cmd_filename(cmd), _t_]];
-     /*<<filename.ml:241:28>>*/ return caml_call2
-            (Stdlib_String[7], cst$13, _u_) /*<<filename.ml:251:5>>*/ ;
+     /*<<filename.ml:241:28>>*/ return Stdlib_String[7].call
+            (null, cst$13, _u_) /*<<filename.ml:251:5>>*/ ;
    }
    function drive_and_path(s){
     var
@@ -35282,13 +35044,14 @@
       /*<<filename.ml:261:9>>*/ return [0, cst$17, s];
     var
      _l_ =
-        /*<<filename.ml:260:9>>*/  /*<<filename.ml:260:28>>*/ caml_call3
-        (Stdlib_String[16],
+        /*<<filename.ml:260:9>>*/  /*<<filename.ml:260:28>>*/ Stdlib_String
+         [16].call
+        (null,
          s,
          2,
           /*<<filename.ml:260:9>>*/ caml_ml_string_length(s) - 2 | 0);
      /*<<filename.ml:260:10>>*/ return [0,
-            caml_call3(Stdlib_String[16], s, 0, 2),
+            Stdlib_String[16].call(null, s, 0, 2),
             _l_] /*<<filename.ml:260:26>>*/ ;
     /*<<filename.ml:261:16>>*/ }
    function dirname$0(s){
@@ -35299,7 +35062,7 @@
      dir =
         /*<<filename.ml:264:14>>*/ generic_dirname
         (is_dir_sep$0, current_dir_name$0, path);
-     /*<<filename.ml:265:4>>*/ return caml_call2(Stdlib[28], drive, dir) /*<<filename.ml:265:15>>*/ ;
+     /*<<filename.ml:265:4>>*/ return Stdlib[28].call(null, drive, dir) /*<<filename.ml:265:15>>*/ ;
    }
    function basename$0(s){
     var path =  /*<<filename.ml:267:25>>*/ drive_and_path(s)[2];
@@ -35371,22 +35134,22 @@
       && !  /*<<filename.ml:298:14>>*/ is_dir_sep$1(dirname, l - 1 | 0)){
      var
       _i_ =
-         /*<<filename.ml:300:17>>*/ caml_call2
-         (Stdlib[28], dir_sep$2, filename);
-      /*<<filename.ml:300:35>>*/ return caml_call2(Stdlib[28], dirname, _i_);
+         /*<<filename.ml:300:17>>*/ Stdlib[28].call(null, dir_sep$2, filename);
+      /*<<filename.ml:300:35>>*/ return Stdlib[28].call(null, dirname, _i_);
     }
-     /*<<filename.ml:299:7>>*/ return caml_call2
-            (Stdlib[28], dirname, filename) /*<<filename.ml:300:35>>*/ ;
+     /*<<filename.ml:299:7>>*/ return Stdlib[28].call(null, dirname, filename) /*<<filename.ml:300:35>>*/ ;
    }
    function chop_suffix(name, suff){
      /*<<filename.ml:303:5>>*/ return check_suffix$1(name, suff)
-            ?  /*<<filename.ml:304:7>>*/ caml_call3
-              (Stdlib_String[16],
+            ?  /*<<filename.ml:304:7>>*/ Stdlib_String
+               [16].call
+              (null,
                name,
                0,
                caml_ml_string_length(name) - caml_ml_string_length(suff) | 0)
-            :  /*<<filename.ml:305:7>>*/ caml_call1
-              (Stdlib[1], cst_Filename_chop_suffix) /*<<filename.ml:305:41>>*/ ;
+            :  /*<<filename.ml:305:7>>*/ Stdlib
+               [1].call
+              (null, cst_Filename_chop_suffix) /*<<filename.ml:305:41>>*/ ;
    }
    function extension_len(name){
     var
@@ -35419,32 +35182,27 @@
     var l =  /*<<filename.ml:321:10>>*/ extension_len(name);
      /*<<filename.ml:322:2>>*/ return 0 === l
             ? cst$18
-            :  /*<<filename.ml:322:24>>*/ caml_call3
-              (Stdlib_String[16],
-               name,
-               caml_ml_string_length(name) - l | 0,
-               l) /*<<filename.ml:322:66>>*/ ;
+            :  /*<<filename.ml:322:24>>*/ Stdlib_String
+               [16].call
+              (null, name, caml_ml_string_length(name) - l | 0, l) /*<<filename.ml:322:66>>*/ ;
    }
    function chop_extension(name){
     var l =  /*<<filename.ml:325:10>>*/ extension_len(name);
      /*<<filename.ml:326:2>>*/ return 0 === l
-            ?  /*<<filename.ml:326:16>>*/ caml_call1
-              (Stdlib[1], cst_Filename_chop_extension)
-            :  /*<<filename.ml:327:7>>*/ caml_call3
-              (Stdlib_String[16],
-               name,
-               0,
-               caml_ml_string_length(name) - l | 0) /*<<filename.ml:327:49>>*/ ;
+            ?  /*<<filename.ml:326:16>>*/ Stdlib
+               [1].call
+              (null, cst_Filename_chop_extension)
+            :  /*<<filename.ml:327:7>>*/ Stdlib_String
+               [16].call
+              (null, name, 0, caml_ml_string_length(name) - l | 0) /*<<filename.ml:327:49>>*/ ;
    }
    function remove_extension(name){
     var l =  /*<<filename.ml:330:10>>*/ extension_len(name);
      /*<<filename.ml:331:2>>*/ return 0 === l
             ? name
-            :  /*<<filename.ml:331:26>>*/ caml_call3
-              (Stdlib_String[16],
-               name,
-               0,
-               caml_ml_string_length(name) - l | 0) /*<<filename.ml:331:68>>*/ ;
+            :  /*<<filename.ml:331:26>>*/ Stdlib_String
+               [16].call
+              (null, name, 0, caml_ml_string_length(name) - l | 0) /*<<filename.ml:331:68>>*/ ;
    }
    var
     prng_key =
@@ -35460,8 +35218,8 @@
        & 16777215;
      /*<<filename.ml:342:18>>*/ return  /*<<filename.ml:342:63>>*/ concat
             (temp_dir,
-              /*<<filename.ml:342:18>>*/ caml_call4
-              (Stdlib_Printf[4], _c_, prefix, rnd, suffix)) /*<<filename.ml:342:63>>*/ ;
+              /*<<filename.ml:342:18>>*/ caml_call3
+              (Stdlib_Printf[4].call(null, _c_), prefix, rnd, suffix)) /*<<filename.ml:342:63>>*/ ;
    }
    var
     current_temp_dir_name =
@@ -35525,7 +35283,7 @@
        _i_ =
           /*<<filename.ml:367:7>>*/ [0,
           name,
-          caml_call3(Stdlib[62], [0, 1, [0, 3, [0, 5, mode]]], perms, name)];
+          Stdlib[62].call(null, [0, 1, [0, 3, [0, 5, mode]]], perms, name)];
       return _i_;
      }
      catch(e$0){
@@ -36183,7 +35941,7 @@
 
 //# unitInfo: Provides: Stdlib__StringLabels
 //# unitInfo: Requires: Stdlib__String
-//# shape: Stdlib__StringLabels:[F(2),F(2),N,F(1),F(1),F(5),F(2),F(2)*,F(2)*,F(2)*,F(2),F(2),F(3),F(3),F(2),F(3),F(2),F(2),F(2),F(3),F(3),F(2),F(2),F(1),F(1),F(1),F(1),F(1),F(1),F(2),F(2),F(3),F(3),F(3),F(3),F(2),F(2),F(2),F(2),F(1),F(1),F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2)]
+//# shape: Stdlib__StringLabels:[F(2),F(2),N,F(1),F(1),F(5),F(2),F(2)*,F(2)*,F(2)*,F(2),F(2),F(3),F(3),F(2),F(3),F(2),F(2),F(2),F(3),F(3),F(2),F(2),F(1),F(1),F(1),F(1),F(1),F(1),F(2),F(2),F(3),F(3),F(3),F(3),F(2),F(2),F(2),F(2),F(1)*,F(1)*,F(1),F(2),F(1),F(2),F(1),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(2),F(1),F(2),F(2),F(2),F(2),F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -36329,7 +36087,7 @@
 
 //# unitInfo: Provides: Stdlib__MoreLabels
 //# unitInfo: Requires: Stdlib__Hashtbl, Stdlib__Map, Stdlib__Set
-//# shape: Stdlib__MoreLabels:[[F(2),F(1),F(1),F(1),F(3),F(2),F(2),F(2),F(2),F(2),F(3),F(2),F(2),F(3),F(1)*,F(1),F(1),F(2),F(1),F(1)*->F(1),F(1),F(1),F(2),F(2),F(1),F(1)*,F(1)*,F(1)*,F(2)*,F(3)*,F(4)*],[F(1)*],[F(1)*]]
+//# shape: Stdlib__MoreLabels:[[F(2),F(1),F(1),F(1),F(3),F(2),F(2),F(2),F(2),F(2),F(3),F(2),F(2),F(3),F(1)*,F(1),F(1),F(2),F(1),F(1)*->F(1),F(1)*->F(1),F(1)*->F(1),F(2),F(2),F(1),F(1)*,F(1)*,F(1)*,F(2)*,F(3)*,F(4)*],[F(1)*],[F(1)*]]
 (function
   (globalThis){
    "use strict";
@@ -36377,11 +36135,6 @@
             ? 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,
@@ -36400,22 +36153,22 @@
     if(tag !== Unhandled)  /*<<effect.ml:28:11>>*/ return 0;
     var
      x =  /*<<effect.ml:22:16>>*/ param[2],
-     _h_ =  /*<<effect.ml:25:12>>*/ caml_call1(Stdlib_Printexc[26], x),
-     msg =  /*<<effect.ml:24:18>>*/ caml_call2(Stdlib_Printf[4], _a_, _h_);
+     _h_ =  /*<<effect.ml:25:12>>*/ Stdlib_Printexc[26].call(null, x),
+     msg =
+        /*<<effect.ml:24:18>>*/ caml_call1
+        (Stdlib_Printf[4].call(null, _a_), _h_);
      /*<<effect.ml:27:8>>*/ return [0, msg];
     /*<<effect.ml:28:15>>*/ }
-    /*<<effect.ml:30:2>>*/ caml_call1(Stdlib_Printexc[9], printer);
+    /*<<effect.ml:30:2>>*/ Stdlib_Printexc[9].call(null, printer);
    var
     Should_not_see_this =
        /*<<effect.ml:30:35>>*/ [248,
        "Stdlib.Effect.Should_not_see_this__",
        caml_fresh_oo_id(0)];
-    /*<<effect.ml:34:8>>*/ caml_call2
-    (Stdlib_Callback[2],
-     "Effect.Unhandled",
-     [0, Unhandled, Should_not_see_this]);
-    /*<<effect.ml:36:8>>*/ caml_call2
-    (Stdlib_Callback[2],
+    /*<<effect.ml:34:8>>*/ Stdlib_Callback[2].call
+    (null, "Effect.Unhandled", [0, Unhandled, Should_not_see_this]);
+    /*<<effect.ml:36:8>>*/ Stdlib_Callback[2].call
+    (null,
      "Effect.Continuation_already_resumed",
      Continuation_already_resumed);
    function continue$(k, v){
@@ -36502,7 +36255,7 @@
              (f,  /*<<effect.ml:118:18>>*/ jsoo_effect_not_supported()) /*<<effect.ml:118:45>>*/ ;
     }
     function error(param){
-      /*<<effect.ml:119:18>>*/ return caml_call1(Stdlib[2], cst_impossible) /*<<effect.ml:119:39>>*/ ;
+      /*<<effect.ml:119:18>>*/ return Stdlib[2].call(null, cst_impossible) /*<<effect.ml:119:39>>*/ ;
     }
     function effc(eff, k, last_fiber){
       /*<<effect.ml:121:6>>*/ if(eff === Initial_setup)

From 8e8456fea198a60fe930f67d4b81e072beb71d5d Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Thu, 5 Dec 2024 08:34:47 +0100
Subject: [PATCH 5/7] Changes

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

diff --git a/CHANGES.md b/CHANGES.md
index 23f90c0550..98dad33af8 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -39,6 +39,7 @@
 * Compiler: deadcode elimination of cyclic values (#1978)
 * Compiler: directly write Wasm binary modules (#2000, #2003)
 * Compiler: rewrote inlining pass (#1935)
+* Compiler: Propagate arity between compilation units (#1594)
 
 ## Bug fixes
 * Compiler: fix stack overflow issues with double translation (#1869)

From 681ff02bba7089c21e7260b760c669ef2bfa1111 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 20 May 2025 20:52:00 +0200
Subject: [PATCH 6/7] Compiler: propagate information during optcall
 optimiastion.

---
 compiler/lib/driver.ml       | 30 +++++++++++++++++-------------
 compiler/lib/global_flow.ml  |  4 ++++
 compiler/lib/global_flow.mli |  2 ++
 compiler/lib/specialize.ml   | 18 ++++++++++--------
 compiler/lib/specialize.mli  |  6 +++++-
 5 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index f77b4542b9..83c251956e 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -65,6 +65,7 @@ let specialize_1 (p, info) =
   let return_values = Code.Var.Map.empty in
   Specialize.f
     ~function_arity:(fun f -> Specialize.function_arity ~return_values info f)
+    ~update_def:(fun x expr -> Flow.Info.update_def info x expr)
     p
 
 let specialize_js (p, info) =
@@ -98,7 +99,6 @@ let ( +> ) f g x = g (f x)
 
 let map_fst4 f (x, y, z, t) = f x, y, z, t
 
-
 let collects_shapes ~shapes (p : Code.program) =
   if debug_shapes () || shapes
   then (
@@ -139,7 +139,6 @@ let collects_shapes ~shapes (p : Code.program) =
     map)
   else StringMap.empty
 
-
 let effects_and_exact_calls ~deadcode_sentinal ~shapes (profile : Profile.t) p =
   let fast =
     match Config.effects (), profile with
@@ -157,21 +156,27 @@ let effects_and_exact_calls ~deadcode_sentinal ~shapes (profile : Profile.t) p =
   in
   match Config.effects () with
   | `Cps | `Double_translation ->
-     if debug () then Format.eprintf "Effects...@.";
-     let shapes = collects_shapes ~shapes p in
-     let p, tramp, cps = Effects.f ~flow_info:info ~live_vars p in
-     let p = match Config.target () with
-           | `Wasm -> p
-           | `JavaScript -> Lambda_lifting.f p in
-     p, tramp, cps, shapes
+      if debug () then Format.eprintf "Effects...@.";
+      let shapes = collects_shapes ~shapes p in
+      let p, tramp, cps = Effects.f ~flow_info:info ~live_vars p in
+      let p =
+        match Config.target () with
+        | `Wasm -> p
+        | `JavaScript -> Lambda_lifting.f p
+      in
+      p, tramp, cps, shapes
   | `Disabled | `Jspi ->
       let p =
-        Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p
+        Specialize.f
+          ~function_arity:(fun f -> Global_flow.function_arity info f)
+          ~update_def:(fun x expr -> Global_flow.update_def info x expr)
+          p
       in
       let shapes = collects_shapes ~shapes p in
       ( p
       , (Code.Var.Set.empty : Effects.trampolined_calls)
-      , (Code.Var.Set.empty : Effects.in_cps), shapes )
+      , (Code.Var.Set.empty : Effects.in_cps)
+      , shapes )
 
 let print p =
   if debug () then Code.Print.program Format.err_formatter (fun _ _ -> "") p;
@@ -644,7 +649,6 @@ let simplify_js js =
   if times () then Format.eprintf "  optimizing: %a@." Timer.print t;
   js
 
-
 let configure formatter =
   let pretty = Config.Flag.pretty () in
   Pretty_print.set_compact formatter (not pretty)
@@ -673,7 +677,7 @@ let optimize ~shapes ~profile p =
        | O2 -> o2
        | O3 -> o3)
     +> specialize_js_once_after
-    +> effects_and_exact_calls ~deadcode_sentinal ~shapes profile 
+    +> effects_and_exact_calls ~deadcode_sentinal ~shapes profile
     +> map_fst4
          (match Config.target (), Config.effects () with
          | `JavaScript, `Disabled -> Generate_closure.f
diff --git a/compiler/lib/global_flow.ml b/compiler/lib/global_flow.ml
index 4fe9d26420..9ad4dbce8a 100644
--- a/compiler/lib/global_flow.ml
+++ b/compiler/lib/global_flow.ml
@@ -716,6 +716,10 @@ let exact_call info f n =
           | Expr _ | Phi _ -> assert false)
         known
 
+let update_def info x expr =
+  let idx = Code.Var.idx x in
+  info.info_defs.(idx) <- Expr expr
+
 let function_arity info f =
   match Var.Tbl.get info.info_approximation f with
   | Top | Values { others = true; _ } -> None
diff --git a/compiler/lib/global_flow.mli b/compiler/lib/global_flow.mli
index 61f5dbfb6a..0124f6357c 100644
--- a/compiler/lib/global_flow.mli
+++ b/compiler/lib/global_flow.mli
@@ -44,6 +44,8 @@ type info =
   ; info_return_vals : Var.Set.t Var.Map.t
   }
 
+val update_def : info -> Code.Var.t -> Code.expr -> unit
+
 val f : fast:bool -> Code.program -> info
 
 val exact_call : info -> Var.t -> int -> bool
diff --git a/compiler/lib/specialize.ml b/compiler/lib/specialize.ml
index a6009fcc6d..c1d8f366c6 100644
--- a/compiler/lib/specialize.ml
+++ b/compiler/lib/specialize.ml
@@ -40,7 +40,7 @@ let unknown_apply = function
   | Let (_, Apply { f = _; args = _; exact = false }) -> true
   | _ -> false
 
-let specialize_apply opt_count function_arity ((acc, free_pc, extra), loc) i =
+let specialize_apply opt_count function_arity update_def ((acc, free_pc, extra), loc) i =
   match i with
   | Let (x, Apply { f; args; exact = false }) -> (
       let n' = List.length args in
@@ -74,13 +74,13 @@ let specialize_apply opt_count function_arity ((acc, free_pc, extra), loc) i =
             ; branch = Return return'
             }
           in
-          ( Let (x, Closure (missing, (free_pc, missing), None)) :: acc
-          , free_pc + 1
-          , (free_pc, block) :: extra )
+          let expr = Closure (missing, (free_pc, missing), None) in
+          update_def x expr;
+          Let (x, expr) :: acc, free_pc + 1, (free_pc, block) :: extra
       | Some _ -> assert false)
   | _ -> i :: acc, free_pc, extra
 
-let specialize_instrs ~function_arity opt_count p =
+let specialize_instrs ~function_arity ~update_def opt_count p =
   let blocks, free_pc =
     Addr.Map.fold
       (fun pc block (blocks, free_pc) ->
@@ -95,7 +95,7 @@ let specialize_instrs ~function_arity opt_count p =
                 | Event loc ->
                     let (body, free_pc, extra), _ = acc in
                     (i :: body, free_pc, extra), Some loc
-                | _ -> specialize_apply opt_count function_arity acc i, None)
+                | _ -> specialize_apply opt_count function_arity update_def acc i, None)
           in
           let blocks =
             List.fold_left extra ~init:blocks ~f:(fun blocks (pc, b) ->
@@ -108,13 +108,15 @@ let specialize_instrs ~function_arity opt_count p =
   in
   { p with blocks; free_pc }
 
-let f ~function_arity p =
+let f ~function_arity ~update_def p =
   Code.invariant p;
   let previous_p = p in
   let t = Timer.make () in
   let opt_count = ref 0 in
   let p =
-    if Config.Flag.optcall () then specialize_instrs ~function_arity opt_count p else p
+    if Config.Flag.optcall ()
+    then specialize_instrs ~function_arity ~update_def opt_count p
+    else p
   in
   if times () then Format.eprintf "  optcall: %a@." Timer.print t;
   if stats () then Format.eprintf "Stats - optcall: %d@." !opt_count;
diff --git a/compiler/lib/specialize.mli b/compiler/lib/specialize.mli
index 5a1a8f7a2a..59d71ea5c2 100644
--- a/compiler/lib/specialize.mli
+++ b/compiler/lib/specialize.mli
@@ -21,6 +21,10 @@
 val function_arity :
   return_values:Code.Var.Set.t Code.Var.Map.t -> Flow.Info.t -> Code.Var.t -> int option
 
-val f : function_arity:(Code.Var.t -> int option) -> Code.program -> Code.program
+val f :
+     function_arity:(Code.Var.t -> int option)
+  -> update_def:(Code.Var.t -> Code.expr -> unit)
+  -> Code.program
+  -> Code.program
 
 val switches : Code.program -> Code.program

From f5d3667561d9b9cf0e2edf679d71f26032641f85 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Wed, 21 May 2025 10:22:30 +0200
Subject: [PATCH 7/7] Compiler: Specialze.f use shapes to compute arity

---
 compiler/lib/driver.ml      | 13 +++---
 compiler/lib/specialize.ml  | 89 +++++++++++++++++++------------------
 compiler/lib/specialize.mli |  5 +--
 3 files changed, 55 insertions(+), 52 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 83c251956e..72e214d92e 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -64,7 +64,7 @@ let specialize_1 (p, info) =
   if debug () then Format.eprintf "Specialize...@.";
   let return_values = Code.Var.Map.empty in
   Specialize.f
-    ~function_arity:(fun f -> Specialize.function_arity ~return_values info f)
+    ~shape:(fun f -> Flow.the_shape_of ~return_values ~pure:Pure_fun.empty info f)
     ~update_def:(fun x expr -> Flow.Info.update_def info x expr)
     p
 
@@ -167,10 +167,13 @@ let effects_and_exact_calls ~deadcode_sentinal ~shapes (profile : Profile.t) p =
       p, tramp, cps, shapes
   | `Disabled | `Jspi ->
       let p =
-        Specialize.f
-          ~function_arity:(fun f -> Global_flow.function_arity info f)
-          ~update_def:(fun x expr -> Global_flow.update_def info x expr)
-          p
+      Specialize.f
+        ~shape:(fun f ->
+          match Global_flow.function_arity info f with
+          | None -> Shape.Top
+          | Some arity -> Shape.Function { arity; pure = false; res = Top })
+        ~update_def:(fun x expr -> Global_flow.update_def info x expr)
+        p
       in
       let shapes = collects_shapes ~shapes p in
       ( p
diff --git a/compiler/lib/specialize.ml b/compiler/lib/specialize.ml
index c1d8f366c6..7837ff3962 100644
--- a/compiler/lib/specialize.ml
+++ b/compiler/lib/specialize.ml
@@ -26,11 +26,6 @@ let stats = Debug.find "stats"
 
 let debug_stats = Debug.find "stats-debug"
 
-let function_arity ~return_values info x =
-  match Flow.the_shape_of ~return_values ~pure:Pure_fun.empty info x with
-  | Top | Block _ -> None
-  | Function { arity; _ } -> Some arity
-
 let add_event loc instrs =
   match loc with
   | Some loc -> Event loc :: instrs
@@ -40,83 +35,91 @@ let unknown_apply = function
   | Let (_, Apply { f = _; args = _; exact = false }) -> true
   | _ -> false
 
-let specialize_apply opt_count function_arity update_def ((acc, free_pc, extra), loc) i =
-  match i with
-  | Let (x, Apply { f; args; exact = false }) -> (
-      let n' = List.length args in
-      match function_arity f with
-      | None -> i :: acc, free_pc, extra
-      | Some n when n = n' ->
-          incr opt_count;
-          Let (x, Apply { f; args; exact = true }) :: acc, free_pc, extra
-      | Some n when n < n' ->
+let specialize_apply opt_count shape update_def =
+  let rec loop x f args shape loc (acc, free_pc, extra) =
+    match (shape : Shape.t) with
+    | Top | Block _ -> Let (x, Apply { f; args; exact = false }) :: acc, free_pc, extra
+    | Function { arity; res; _ } ->
+        let nargs = List.length args in
+        if arity = nargs
+        then (
           incr opt_count;
-          let v = Code.Var.fresh () in
-          let args, rest = List.take n args in
-          ( (* Reversed *)
-            Let (x, Apply { f = v; args = rest; exact = false })
-            :: add_event loc (Let (v, Apply { f; args; exact = true }) :: acc)
-          , free_pc
-          , extra )
-      | Some n when n > n' ->
+          let expr = Apply { f; args; exact = true } in
+          update_def x expr;
+          Let (x, expr) :: acc, free_pc, extra)
+        else if arity > nargs
+        then (
+          (* under application *)
           incr opt_count;
-          let missing = Array.init (n - n') ~f:(fun _ -> Code.Var.fresh ()) in
+          let missing = Array.init (arity - nargs) ~f:(fun _ -> Code.Var.fresh ()) in
           let missing = Array.to_list missing in
           let block =
-            let params' = Array.init (n - n') ~f:(fun _ -> Code.Var.fresh ()) in
-            let params' = Array.to_list params' in
+            let params' = List.map missing ~f:Code.Var.fork in
             let return' = Code.Var.fresh () in
+            let args = args @ params' in
+            assert (List.length args = arity);
             { params = params'
-            ; body =
-                add_event
-                  loc
-                  [ Let (return', Apply { f; args = args @ params'; exact = true }) ]
+            ; body = add_event loc [ Let (return', Apply { f; args; exact = true }) ]
             ; branch = Return return'
             }
           in
           let expr = Closure (missing, (free_pc, missing), None) in
           update_def x expr;
-          Let (x, expr) :: acc, free_pc + 1, (free_pc, block) :: extra
-      | Some _ -> assert false)
-  | _ -> i :: acc, free_pc, extra
+          Let (x, expr) :: acc, free_pc + 1, (free_pc, block) :: extra)
+        else (
+          assert (arity < nargs);
+          (* over application *)
+          incr opt_count;
+          let v = Code.Var.fresh () in
+          let args, rest = List.take arity args in
+          let exact_expr = Apply { f; args; exact = true } in
+          let body =
+            (* Reversed *)
+            add_event loc (Let (v, exact_expr) :: acc)
+          in
+          loop x v rest res loc (body, free_pc, extra))
+  in
+  fun i (((body_rev, free_pc, extra) as acc), loc) ->
+    match i with
+    | Let (x, Apply { f; args; exact = false }) -> loop x f args (shape f) loc acc
+    | _ -> i :: body_rev, free_pc, extra
 
-let specialize_instrs ~function_arity ~update_def opt_count p =
+let specialize_instrs ~shape ~update_def opt_count p =
   let blocks, free_pc =
+    let specialize_instrs = specialize_apply opt_count shape update_def in
     Addr.Map.fold
       (fun pc block (blocks, free_pc) ->
         if List.exists ~f:unknown_apply block.body
         then
-          let (body, free_pc, extra), _ =
+          let (body_rev, free_pc, extra), _ =
             List.fold_left
               block.body
               ~init:(([], free_pc, []), None)
               ~f:(fun acc i ->
                 match i with
                 | Event loc ->
-                    let (body, free_pc, extra), _ = acc in
-                    (i :: body, free_pc, extra), Some loc
-                | _ -> specialize_apply opt_count function_arity update_def acc i, None)
+                    let (body_rev, free_pc, extra), _ = acc in
+                    (i :: body_rev, free_pc, extra), Some loc
+                | _ -> specialize_instrs i acc, None)
           in
           let blocks =
             List.fold_left extra ~init:blocks ~f:(fun blocks (pc, b) ->
                 Addr.Map.add pc b blocks)
           in
-          Addr.Map.add pc { block with Code.body = List.rev body } blocks, free_pc
+          Addr.Map.add pc { block with Code.body = List.rev body_rev } blocks, free_pc
         else blocks, free_pc)
       p.blocks
       (p.blocks, p.free_pc)
   in
   { p with blocks; free_pc }
 
-let f ~function_arity ~update_def p =
+let f ~shape ~update_def p =
   Code.invariant p;
   let previous_p = p in
   let t = Timer.make () in
   let opt_count = ref 0 in
   let p =
-    if Config.Flag.optcall ()
-    then specialize_instrs ~function_arity ~update_def opt_count p
-    else p
+    if Config.Flag.optcall () then specialize_instrs ~shape ~update_def opt_count p else p
   in
   if times () then Format.eprintf "  optcall: %a@." Timer.print t;
   if stats () then Format.eprintf "Stats - optcall: %d@." !opt_count;
diff --git a/compiler/lib/specialize.mli b/compiler/lib/specialize.mli
index 59d71ea5c2..2ab4f3ecb5 100644
--- a/compiler/lib/specialize.mli
+++ b/compiler/lib/specialize.mli
@@ -18,11 +18,8 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *)
 
-val function_arity :
-  return_values:Code.Var.Set.t Code.Var.Map.t -> Flow.Info.t -> Code.Var.t -> int option
-
 val f :
-     function_arity:(Code.Var.t -> int option)
+     shape:(Code.Var.t -> Shape.t)
   -> update_def:(Code.Var.t -> Code.expr -> unit)
   -> Code.program
   -> Code.program