From c33f23ec43d6580a47a01de619991089a75ab243 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 01/13] 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 efc9ce2a4cc8d2dbb2a7b7ef6d97c651aff61e97 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 02/13] 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 315fb00e14..d3eeb8f929 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 77383c7fbf5094afe4e6f5e1ba1b38257b730846 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 03/13] 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                     | 124 +++++++++++----
 compiler/lib/driver.mli                    |   9 +-
 compiler/lib/flow.ml                       | 102 +++++++++---
 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, 914 insertions(+), 155 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 203a4fa784..2b2d5b2ea6 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)]. "
@@ -317,7 +327,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
@@ -388,6 +400,8 @@ let options =
       ; source_map
       ; keep_unit_names
       ; effects
+      ; shape_files
+      ; write_shape
       }
   in
   let t =
@@ -420,7 +434,9 @@ let options =
       $ input_file
       $ js_files
       $ keep_unit_names
-      $ effects)
+      $ effects
+      $ shape_files
+      $ write_shape)
   in
   Term.ret t
 
@@ -649,6 +665,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 d0f39f6c28..8b9ee787df 100644
--- a/compiler/bin-wasm_of_ocaml/compile.ml
+++ b/compiler/bin-wasm_of_ocaml/compile.ml
@@ -246,7 +246,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; _ }, global_flow_data =
-    Driver.optimize_for_wasm ~profile code
+    Driver.optimize_for_wasm ~profile ~shapes:false code
   in
   let context = Generate.start () in
   let _ =
@@ -400,7 +400,7 @@ let run
     let standalone = Option.is_none unit_name in
     let Driver.{ program; variable_uses; in_cps; deadcode_sentinal; _ }, global_flow_data
         =
-      Driver.optimize_for_wasm ~profile code
+      Driver.optimize_for_wasm ~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 4581c38d5d..680a105a48 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
@@ -93,9 +96,54 @@ let phi p =
 
 let ( +> ) f g x = g (f x)
 
-let map_fst f (x, y) = f x, y
+let map_fst5 f (x, y, z, t, u) = f x, y, z, t, u
 
-let effects_and_exact_calls ~keep_flow_data ~deadcode_sentinal (profile : Profile.t) p =
+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
+    ~keep_flow_data
+    ~deadcode_sentinal
+    ~shapes
+    (profile : Profile.t)
+    p =
   let fast =
     match Config.effects (), profile with
     | (`Cps | `Double_translation), _ -> false
@@ -116,20 +164,24 @@ let effects_and_exact_calls ~keep_flow_data ~deadcode_sentinal (profile : Profil
   match Config.effects () with
   | `Cps | `Double_translation ->
       if debug () then Format.eprintf "Effects...@.";
+      let shapes = collects_shapes ~shapes p in
       let p, trampolined_calls, in_cps = Effects.f ~flow_info:info ~live_vars p in
-      (p, (trampolined_calls, in_cps, None))
-      |> map_fst
-           (match Config.target () with
-           | `Wasm -> Fun.id
-           | `JavaScript -> Lambda_lifting.f)
+      let p =
+        match Config.target () with
+        | `Wasm -> p
+        | `JavaScript -> Lambda_lifting.f p
+      in
+      p, trampolined_calls, in_cps, None, 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)
-        , global_flow_data ) )
+      , (Code.Var.Set.empty : Effects.trampolined_calls)
+      , (Code.Var.Set.empty : Effects.in_cps)
+      , global_flow_data
+      , shapes )
 
 let print p =
   if debug () then Code.Print.program Format.err_formatter (fun _ _ -> "") p;
@@ -176,7 +228,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
@@ -617,7 +669,7 @@ let link_and_pack ?(standalone = true) ?(wrap_with_fun = `Iife) ?(link = `No) p
   |> pack ~wrap_with_fun ~standalone
   |> check_js
 
-let optimize ~profile ~keep_flow_data p =
+let optimize ~shapes ~profile ~keep_flow_data p =
   let deadcode_sentinal =
     (* If deadcode is disabled, this field is just fresh variable *)
     Code.Var.fresh_n "dummy"
@@ -630,31 +682,35 @@ let optimize ~profile ~keep_flow_data p =
        | O2 -> o2
        | O3 -> o3)
     +> specialize_js_once_after
-    +> effects_and_exact_calls ~keep_flow_data ~deadcode_sentinal profile
-    +> map_fst
+    +> effects_and_exact_calls ~keep_flow_data ~deadcode_sentinal ~shapes profile
+    +> map_fst5
          (match Config.target (), Config.effects () with
          | `JavaScript, `Disabled -> Generate_closure.f
          | `JavaScript, (`Cps | `Double_translation) | `Wasm, (`Disabled | `Jspi | `Cps)
            -> Fun.id
          | `JavaScript, `Jspi | `Wasm, `Double_translation -> assert false)
-    +> map_fst deadcode'
+    +> map_fst5 deadcode'
   in
   if times () then Format.eprintf "Start Optimizing...@.";
   let t = Timer.make () in
-  let (program, variable_uses), (trampolined_calls, in_cps, global_flow_info) = opt p in
+  let (program, variable_uses), trampolined_calls, in_cps, global_flow_info, 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 }
   , global_flow_info )
 
-let optimize_for_wasm ~profile p =
-  let optimized_code, global_flow_data = optimize ~profile ~keep_flow_data:true p in
+let optimize_for_wasm ~shapes ~profile p =
+  let optimized_code, global_flow_data =
+    optimize ~shapes ~profile ~keep_flow_data:true p
+  in
   ( optimized_code
   , match global_flow_data with
     | Some data -> data
     | None -> Global_flow.f ~fast:false optimized_code.program )
 
-let full ~standalone ~wrap_with_fun ~profile ~link ~source_map ~formatter p =
-  let optimized_code, _ = optimize ~profile ~keep_flow_data:false p in
+let full ~standalone ~wrap_with_fun ~shapes ~profile ~link ~source_map ~formatter p =
+  let optimized_code, _ = optimize ~shapes ~profile ~keep_flow_data:false p in
   let exported_runtime = not standalone in
   let emit formatter =
     generate ~exported_runtime ~wrap_with_fun ~warn_on_unhandled_effect:standalone
@@ -663,11 +719,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
   ()
 
@@ -675,11 +741,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)
@@ -688,12 +755,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 418e6d71e4..5630d18e50 100644
--- a/compiler/lib/driver.mli
+++ b/compiler/lib/driver.mli
@@ -18,16 +18,20 @@
  * 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_for_wasm :
-     profile:Profile.t
+     shapes:bool
+  -> profile:Profile.t
   -> Code.program
   -> optimized_result * (Global_flow.state * Global_flow.info)
 
@@ -35,11 +39,12 @@ 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..13de7ffb74 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,66 @@ 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
+      let acc = Var.Set.add x acc in
+      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 e6bb26b7cf..5a864d4979 100644
--- a/compiler/lib/parse_bytecode.ml
+++ b/compiler/lib/parse_bytecode.ml
@@ -585,6 +585,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 =
@@ -669,8 +672,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
@@ -693,20 +705,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
@@ -799,6 +828,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
@@ -2500,18 +2538,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
@@ -2677,7 +2725,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) ->
@@ -2807,7 +2855,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 =
@@ -2939,7 +2987,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);
@@ -2948,7 +2996,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 838afc7814..9e9052dc72 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";
@@ -980,7 +982,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){
@@ -1096,6 +1100,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";
@@ -1203,6 +1208,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";
@@ -1380,6 +1386,7 @@
 
 //# unitInfo: Provides: Stdlib__Type
 //# unitInfo: Requires: Stdlib__Obj
+//# shape: Stdlib__Type:[[F(1)*,F(1),F(2)*]]
 (function
   (globalThis){
    "use strict";
@@ -1412,7 +1419,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,
@@ -1449,6 +1458,7 @@
 
 //# unitInfo: Provides: CamlinternalLazy
 //# unitInfo: Requires: Stdlib, Stdlib__Obj
+//# shape: CamlinternalLazy:[N,F(1),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -1525,6 +1535,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";
@@ -1620,6 +1631,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";
@@ -2545,6 +2557,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";
@@ -2670,6 +2683,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";
@@ -2836,7 +2850,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;}
@@ -2874,6 +2890,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";
@@ -2975,6 +2992,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";
@@ -3144,6 +3162,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";
@@ -4779,7 +4798,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){
@@ -4827,6 +4848,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";
@@ -6388,6 +6410,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";
@@ -6956,7 +6979,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){
@@ -6976,6 +7001,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";
@@ -7056,6 +7082,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";
@@ -8029,6 +8056,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";
@@ -9138,6 +9166,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";
@@ -9273,6 +9302,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";
@@ -9421,6 +9451,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";
@@ -9544,6 +9575,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";
@@ -9841,6 +9873,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";
@@ -10099,6 +10132,7 @@
 
 //# unitInfo: Provides: Stdlib__Set
 //# unitInfo: Requires: Stdlib, Stdlib__List, Stdlib__Seq
+//# shape: Stdlib__Set:[F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -11158,6 +11192,7 @@
 
 //# unitInfo: Provides: Stdlib__Map
 //# unitInfo: Requires: Stdlib, Stdlib__List, Stdlib__Seq
+//# shape: Stdlib__Map:[F(1)*]
 (function
   (globalThis){
    "use strict";
@@ -12201,6 +12236,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";
@@ -12337,6 +12373,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";
@@ -12553,6 +12590,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";
@@ -13204,7 +13242,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,
@@ -13244,7 +13284,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,
@@ -13261,6 +13303,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";
@@ -13370,6 +13413,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";
@@ -13648,6 +13692,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";
@@ -20764,6 +20809,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";
@@ -20880,6 +20926,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";
@@ -21731,6 +21778,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";
@@ -22339,6 +22387,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";
@@ -22437,6 +22486,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";
@@ -22634,6 +22684,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";
@@ -22990,6 +23041,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";
@@ -23102,6 +23154,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";
@@ -23429,6 +23482,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";
@@ -24061,6 +24115,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";
@@ -24638,6 +24693,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";
@@ -25753,6 +25809,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";
@@ -26327,6 +26384,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";
@@ -28553,6 +28611,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";
@@ -30770,6 +30829,7 @@
 
 //# unitInfo: Provides: Stdlib__Callback
 //# unitInfo: Requires: Stdlib, Stdlib__Obj
+//# shape: Stdlib__Callback:[F(2),F(2)]
 (function
   (globalThis){
    "use strict";
@@ -30793,6 +30853,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";
@@ -31761,6 +31822,7 @@
 
 //# unitInfo: Provides: Stdlib__Oo
 //# unitInfo: Requires: CamlinternalOO
+//# shape: Stdlib__Oo:[F(1),F(1),F(1)]
 (function
   (globalThis){
    "use strict";
@@ -31779,6 +31841,7 @@
 
 //# unitInfo: Provides: CamlinternalMod
 //# unitInfo: Requires: CamlinternalLazy, CamlinternalOO, Stdlib, Stdlib__Obj
+//# shape: CamlinternalMod:[F(2),F(3)]
 (function
   (globalThis){
    "use strict";
@@ -31950,6 +32013,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";
@@ -33265,6 +33329,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";
@@ -34525,6 +34590,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";
@@ -35533,6 +35599,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";
@@ -35671,6 +35738,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";
@@ -35771,6 +35839,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";
@@ -35925,6 +35994,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";
@@ -36115,6 +36185,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";
@@ -36260,6 +36331,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";
@@ -36276,7 +36348,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");
@@ -36287,6 +36361,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 3a03a93c00a84928d30fbae7fddb18cfc21fde7e 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 04/13] 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 | 4055 +++++++++-----------
 4 files changed, 1914 insertions(+), 2181 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 680a105a48..c237302744 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -65,7 +65,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 9e9052dc72..eb95ae0714 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,
@@ -820,7 +815,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];
@@ -1216,13 +1211,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;
@@ -1255,13 +1244,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];}
@@ -1280,7 +1270,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){
@@ -1291,7 +1281,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
@@ -1335,8 +1325,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 =
@@ -1390,13 +1380,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",
@@ -1406,8 +1391,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>>*/ ;
@@ -1545,18 +1530,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);
@@ -1584,7 +1564,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>>*/ ;
@@ -1599,7 +1579,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>>*/ ;
@@ -1609,7 +1589,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>>*/ ;
@@ -1631,7 +1611,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";
@@ -2033,7 +2013,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>>*/ ;
@@ -2128,7 +2108,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){
@@ -2152,7 +2132,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);
@@ -2210,12 +2190,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){
@@ -2224,10 +2204,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){
@@ -2557,7 +2537,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";
@@ -2587,7 +2567,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>>*/ }
@@ -2654,9 +2634,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,
@@ -2683,7 +2666,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";
@@ -2718,14 +2701,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>>*/ }
@@ -2819,9 +2801,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,
@@ -2899,13 +2884,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 = "\\'",
@@ -2918,7 +2897,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:
@@ -3001,18 +2980,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",
@@ -3028,7 +2996,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){
@@ -3036,7 +3004,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){
@@ -3053,11 +3021,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;
@@ -3069,12 +3037,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;}
@@ -3211,23 +3177,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;
@@ -3237,7 +3203,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;
@@ -3281,7 +3247,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)
@@ -3320,7 +3286,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;
@@ -3516,7 +3482,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];
         }
@@ -3531,7 +3497,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;
@@ -3551,7 +3517,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){
@@ -3567,7 +3533,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){
@@ -3588,7 +3554,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){
@@ -3603,7 +3569,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;
@@ -3647,7 +3613,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){
@@ -3668,7 +3634,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){
@@ -4013,7 +3979,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],
@@ -4046,7 +4012,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){
@@ -4184,7 +4150,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;
@@ -4959,8 +4925,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
@@ -4974,7 +4940,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>>*/ }
@@ -4990,8 +4956,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)
@@ -5002,8 +4968,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
@@ -5014,7 +4980,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
@@ -5026,8 +4992,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
@@ -5080,7 +5046,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;
       }
      }
@@ -5480,15 +5446,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;
@@ -5508,8 +5474,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;
@@ -5528,8 +5494,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);
@@ -5544,8 +5510,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>>*/ ;
@@ -5562,8 +5528,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,
@@ -5623,19 +5589,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;
@@ -5782,8 +5748,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;
@@ -5824,59 +5790,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:620:15>>*/ 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:622:15>>*/ 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:626:15>>*/ 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:628:15>>*/ caml_bytes_unsafe_get(b, i$5);
            /*<<bytes.ml:628:29>>*/ if(not_in_x80_to_xBF(b2$1))
-            /*<<bytes.ml:628:55>>*/ return 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:630:15>>*/ 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:642:15>>*/ 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:644:15>>*/ 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:646:15>>*/ 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>>*/ ;
@@ -5885,22 +5851,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:634:15>>*/ 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:636:15>>*/ 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:638:15>>*/ caml_bytes_unsafe_get(b, i$9);
            /*<<bytes.ml:638:29>>*/ return not_in_x80_to_xBF(b3$0)
-                  ?  /*<<bytes.ml:638:55>>*/ caml_call1(dec_invalid, 3)
+                  ?  /*<<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>>*/ ;
@@ -5909,31 +5875,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:608:15>>*/ 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:610:15>>*/ caml_bytes_unsafe_get(b, i$14);
         /*<<bytes.ml:610:29>>*/ return not_in_x80_to_xBF(b2$4)
-               ?  /*<<bytes.ml:610:55>>*/ caml_call1(dec_invalid, 2)
+               ?  /*<<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:614:15>>*/ 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:616:15>>*/ 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>>*/ ;
      }
@@ -5942,14 +5908,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:604:15>>*/ 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_){
@@ -5957,7 +5923,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);
@@ -6157,15 +6123,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
@@ -6173,17 +6138,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);
@@ -6206,8 +6171,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;
@@ -6237,15 +6202,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
@@ -6253,17 +6217,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);
@@ -6286,8 +6250,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;
@@ -6410,7 +6374,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";
@@ -6434,11 +6398,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,
@@ -6448,20 +6407,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],
@@ -6487,7 +6444,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;
       }
      }
@@ -6522,7 +6479,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
@@ -6568,32 +6525,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;
@@ -6617,17 +6572,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;
@@ -6663,15 +6618,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;
@@ -6692,8 +6647,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;
@@ -6712,8 +6667,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);
@@ -6728,8 +6683,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>>*/ ;
@@ -6746,28 +6701,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
@@ -6831,80 +6786,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 =
@@ -7009,13 +6964,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,
@@ -7026,8 +6975,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",
@@ -7037,8 +6986,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>>*/ ;
@@ -7051,18 +7000,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 =
@@ -7103,11 +7052,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 = "",
@@ -7132,7 +7076,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
@@ -7152,7 +7096,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;
@@ -7170,7 +7114,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;
@@ -7220,13 +7164,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
@@ -7238,7 +7182,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;
@@ -7255,8 +7199,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_;
@@ -7320,8 +7264,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 =
@@ -7499,7 +7443,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;
@@ -7512,7 +7456,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;
@@ -7628,7 +7572,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]]),
@@ -7924,17 +7868,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];
@@ -7979,8 +7920,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>>*/ },
@@ -8086,11 +8027,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,
@@ -8227,7 +8163,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),
@@ -8246,8 +8182,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,
@@ -8265,8 +8201,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
@@ -8287,8 +8223,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
@@ -8334,7 +8270,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;
      }
     }
@@ -8390,8 +8326,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>>*/ ;
    }
@@ -8399,7 +8335,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(;;){
@@ -8426,8 +8362,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_;
@@ -8475,8 +8411,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,
@@ -8973,14 +8909,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,
@@ -9586,31 +9522,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],
@@ -9666,8 +9582,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],
@@ -9676,20 +9592,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,
@@ -9720,8 +9637,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;
             },
@@ -9741,14 +9658,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,
@@ -9784,19 +9701,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>>*/ ;
@@ -9889,16 +9806,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,
@@ -9935,23 +9842,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>>*/ }
@@ -10038,7 +9944,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
@@ -10150,11 +10056,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,
@@ -10200,7 +10101,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],
@@ -10210,7 +10111,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],
@@ -10224,7 +10125,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],
@@ -10234,7 +10135,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],
@@ -10353,8 +10254,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];
@@ -10981,7 +10882,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)
@@ -11040,8 +10941,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];
@@ -11055,8 +10955,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>>*/ ;
                   },
@@ -11258,7 +11158,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],
@@ -11269,7 +11169,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],
@@ -11287,7 +11187,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],
@@ -11298,7 +11198,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],
@@ -11566,8 +11466,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];
@@ -12084,8 +11984,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>>*/ ;
@@ -12094,8 +11994,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>>*/ ;
@@ -12236,29 +12136,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,
@@ -12325,17 +12209,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>>*/ ;
              },
@@ -12547,8 +12431,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>>*/ ;
              },
@@ -12616,26 +12500,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,
@@ -12657,19 +12521,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
@@ -12679,9 +12543,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
@@ -12692,7 +12556,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];
@@ -12720,11 +12584,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){
@@ -12757,8 +12621,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;
@@ -12773,8 +12636,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;
@@ -12789,8 +12651,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;
@@ -12807,7 +12668,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],
@@ -12816,8 +12677,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
@@ -12834,7 +12695,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],
@@ -12843,8 +12704,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
@@ -12868,7 +12729,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
@@ -12881,8 +12742,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,
@@ -12902,8 +12763,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
@@ -12962,8 +12823,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;
          }
@@ -13003,8 +12864,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];
         }
        }
@@ -13038,7 +12899,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){
@@ -13071,8 +12932,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>>*/ ;
    }
@@ -13309,18 +13170,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,
@@ -13330,41 +13180,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){
@@ -13374,33 +13224,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
@@ -13430,21 +13280,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(),
@@ -13465,13 +13300,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
@@ -13479,9 +13314,9 @@
       ki =  /*<<domain.ml:113:20>>*/ [0, k, split];
       /*<<domain.ml:104:4>>*/ 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;
      }
     }
@@ -13501,8 +13336,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;
@@ -13542,8 +13376,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>>*/ ;
@@ -13562,7 +13396,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>>*/ }],
@@ -13570,7 +13404,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];
@@ -13604,9 +13438,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){
@@ -13614,10 +13448,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,
@@ -13626,9 +13460,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);
@@ -13654,14 +13488,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;
@@ -13855,8 +13688,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
@@ -13869,11 +13702,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
@@ -13887,11 +13720,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>>*/ }
@@ -14010,12 +13843,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>>*/ }
@@ -14028,13 +13861,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){
@@ -14082,7 +13915,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),
@@ -14106,11 +13939,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
@@ -14134,15 +13967,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){
@@ -14160,7 +13992,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;
@@ -14168,8 +14000,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){
@@ -14184,8 +14015,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;
@@ -14195,8 +14026,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;
@@ -14213,7 +14044,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;
@@ -14253,8 +14084,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")
@@ -14264,8 +14095,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);
@@ -14277,8 +14108,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>>*/ ;
@@ -14350,10 +14181,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){
@@ -15619,8 +15450,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,
@@ -15652,8 +15484,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;
         }
@@ -16252,12 +16085,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);
@@ -16265,8 +16099,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,
@@ -16673,24 +16508,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);
@@ -16708,8 +16545,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],
@@ -16791,30 +16629,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:
@@ -16832,13 +16671,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:
@@ -16857,25 +16691,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:
@@ -16899,21 +16728,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:
@@ -16927,18 +16751,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;
@@ -16948,12 +16767,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;
@@ -16961,21 +16780,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);
@@ -16983,8 +16802,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>>*/ ;
    }
@@ -17046,8 +16864,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){
@@ -17244,16 +17062,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>>*/ ;
@@ -17289,19 +17108,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:
@@ -17525,8 +17344,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){
@@ -17807,8 +17627,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];
@@ -18197,8 +18018,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],
@@ -18409,8 +18231,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],
@@ -18418,15 +18240,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;
@@ -18437,24 +18259,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>>*/ ;
      }
     }
    }
@@ -18472,8 +18293,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],
@@ -18481,15 +18302,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;
@@ -18504,19 +18325,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>>*/ ;
      }
     }
    }
@@ -18534,8 +18355,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],
@@ -18543,15 +18364,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;
@@ -18559,8 +18380,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;
@@ -18568,19 +18389,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>>*/ ;
      }
     }
    }
@@ -18588,15 +18409,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>>*/ ;
    }
@@ -18634,8 +18454,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(;;){
@@ -18657,8 +18477,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){
@@ -20056,8 +19876,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),
@@ -20084,8 +19904,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),
@@ -20152,8 +19972,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),
@@ -20225,15 +20045,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 =
@@ -20274,7 +20094,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_;
@@ -20514,8 +20334,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){
@@ -20726,8 +20546,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>>*/ ;
     }
@@ -20819,16 +20639,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,
@@ -20836,11 +20646,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,
@@ -20848,11 +20658,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,
@@ -20860,8 +20670,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
@@ -20888,13 +20698,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
@@ -20969,16 +20779,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",
@@ -21033,17 +20833,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);
@@ -21075,14 +20875,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],
@@ -21092,24 +20893,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],
@@ -21179,7 +20981,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
@@ -21190,34 +20992,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(;;){
@@ -21226,7 +21028,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,
@@ -21239,13 +21041,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,
@@ -21299,7 +21100,7 @@
                arg =  /*<<arg.ml:196:22>>*/ get_arg$0(0);
                /*<<arg.ml:124:2>>*/ 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){
@@ -21381,15 +21182,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>>*/ ;
               }
@@ -21400,7 +21201,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];
@@ -21423,7 +21224,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];
@@ -21442,17 +21243,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>>*/ };
@@ -21507,14 +21308,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){
@@ -21529,14 +21332,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){
@@ -21554,14 +21359,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){
@@ -21577,12 +21384,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;
@@ -21598,19 +21405,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;
@@ -21625,11 +21432,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;
@@ -21638,19 +21445,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],
@@ -21665,34 +21472,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),
@@ -21700,32 +21508,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;
@@ -21738,15 +21547,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_);}
@@ -21808,20 +21617,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(),
@@ -21852,7 +21656,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"],
@@ -21904,30 +21708,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;
@@ -21935,7 +21741,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];
@@ -21950,24 +21756,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];
@@ -21977,7 +21784,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])
@@ -21987,9 +21794,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$,
@@ -22003,9 +21809,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,
@@ -22020,9 +21825,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,
@@ -22038,29 +21842,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){
@@ -22076,37 +21882,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: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: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: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,
@@ -22120,8 +21940,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;
@@ -22143,7 +21963,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){
@@ -22155,14 +21975,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>>*/ ;
@@ -22224,11 +22045,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_;
     }
@@ -22259,17 +22080,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 =
@@ -22301,7 +22123,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:353:4>>*/ try{
@@ -22317,17 +22139,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_;
      }
@@ -22336,8 +22160,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_;
     }
@@ -22429,16 +22253,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){
@@ -22450,7 +22274,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);
@@ -22462,7 +22286,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);
@@ -22504,16 +22328,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;
@@ -22598,34 +22412,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
@@ -22636,12 +22471,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>>*/ ;
       });
@@ -22706,21 +22541,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,
@@ -22733,10 +22553,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>>*/ ;
@@ -22749,8 +22569,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>>*/ ;
    }
@@ -22762,7 +22585,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);
@@ -22773,7 +22596,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);
@@ -22784,7 +22607,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);
@@ -22809,12 +22632,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){
@@ -22847,12 +22670,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);
@@ -22867,8 +22690,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,
@@ -22898,19 +22721,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){
@@ -22931,15 +22755,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);
@@ -22955,8 +22779,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;
@@ -22964,7 +22788,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);
@@ -22977,7 +22801,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);
@@ -22994,7 +22818,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;
@@ -23051,11 +22875,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,
@@ -23067,10 +22886,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>>*/ ;
@@ -23083,8 +22902,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>>*/ ;
    }
@@ -23113,8 +22935,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],
@@ -23177,23 +22999,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,
@@ -23212,7 +23018,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),
@@ -23234,7 +23040,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){
@@ -23245,10 +23051,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
@@ -23262,14 +23068,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],
@@ -23291,7 +23097,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>>*/ ;
     }
@@ -23304,7 +23110,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>>*/ ;
     }
@@ -23321,11 +23127,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);
@@ -23338,37 +23144,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,
@@ -23408,38 +23213,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
@@ -23649,8 +23454,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)),
@@ -23824,8 +23629,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_;
@@ -23971,16 +23776,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_;
@@ -24011,26 +23816,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>>*/ ;
@@ -24153,11 +23962,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:",
@@ -24199,21 +24003,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>>*/ }
@@ -24228,20 +24027,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){
@@ -24262,23 +24061,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>>*/ ;
@@ -24320,12 +24119,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
@@ -24351,7 +24149,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>>*/ ;
@@ -24377,16 +24175,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(;;){
@@ -24425,17 +24223,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>>*/ ;
@@ -24693,7 +24491,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";
@@ -24721,11 +24519,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],
@@ -24742,9 +24535,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;
@@ -24774,16 +24567,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 =
@@ -24804,38 +24597,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>>*/ ;
@@ -24864,10 +24657,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];
@@ -24876,10 +24669,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 =
@@ -24904,39 +24697,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);
@@ -24952,9 +24745,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 =
@@ -24967,15 +24760,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);
@@ -24992,9 +24785,9 @@
      /*<<hashtbl.ml:197:2>>*/ if(1 - old_trav)
       /*<<hashtbl.ml:197:23>>*/ flip_ongoing_traversal(h);
      /*<<hashtbl.ml:198: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],
@@ -25026,15 +24819,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);
@@ -25052,10 +24845,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],
@@ -25073,15 +24866,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);
@@ -25105,17 +24898,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] =
@@ -25134,8 +24927,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)
@@ -25148,19 +24941,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){
@@ -25383,8 +25180,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>>*/ ;
@@ -25392,8 +25189,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>>*/ ;
@@ -25503,8 +25300,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
@@ -25719,8 +25517,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>>*/ ;
@@ -25728,8 +25526,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>>*/ ;
@@ -25746,7 +25544,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
@@ -25839,11 +25637,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,
@@ -25863,7 +25656,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){
@@ -25874,7 +25667,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);
@@ -25912,7 +25705,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
@@ -25969,8 +25762,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(;;){
@@ -25994,8 +25787,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(;;){
@@ -26016,8 +25809,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(;;){
@@ -26052,8 +25845,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_);
               },
@@ -26064,8 +25857,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),
@@ -26107,19 +25900,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;
@@ -26178,8 +25969,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_;
            }
@@ -26332,17 +26123,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],
@@ -26409,11 +26196,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(),
@@ -26454,8 +26236,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,
@@ -26478,11 +26260,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
@@ -26495,7 +26277,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];
@@ -26518,7 +26300,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
@@ -26536,29 +26318,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
@@ -26571,7 +26353,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
@@ -26599,7 +26381,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
@@ -26651,7 +26433,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
@@ -26681,8 +26463,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
@@ -26696,25 +26477,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],
@@ -26722,11 +26503,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;
@@ -26741,14 +26522,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],
@@ -26764,7 +26544,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:
@@ -26772,7 +26552,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;
      }
@@ -26782,8 +26562,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;
@@ -26793,54 +26572,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;
@@ -26882,20 +26661,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>>*/ ;
       },
@@ -26912,10 +26691,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>>*/ ;
@@ -26925,8 +26704,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>>*/ ;
@@ -26937,24 +26716,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;
@@ -26983,24 +26762,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],
@@ -27023,31 +26802,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];
@@ -27057,16 +26836,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];
@@ -27085,12 +26864,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;
@@ -27100,20 +26879,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){
@@ -27144,11 +26923,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];
@@ -27198,14 +26977,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);
@@ -27214,22 +26992,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;
    }
@@ -27238,40 +27020,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,
@@ -27281,7 +27063,7 @@
             1,
             1,
             1,
-            _J_,
+            _V_,
             cst$14,
             f,
             g,
@@ -27306,39 +27088,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),
@@ -27366,18 +27154,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 =
@@ -27385,16 +27173,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
@@ -27402,36 +27190,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>>*/ });
@@ -27444,36 +27232,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>>*/ });
@@ -27497,8 +27285,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){
@@ -27518,20 +27306,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
@@ -27539,10 +27329,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];
@@ -27552,7 +27345,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);
@@ -27568,8 +27361,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);
@@ -28019,15 +27812,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")
@@ -28089,8 +27883,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>>*/ ;
@@ -28149,7 +27942,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>>*/ ;
@@ -28158,7 +27951,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>>*/ ;
@@ -28196,8 +27989,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>>*/ ;
@@ -28267,7 +28059,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>>*/ ;
@@ -28276,7 +28068,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>>*/ ;
@@ -28286,8 +28078,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>>*/ ;
@@ -28297,16 +28089,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;}
@@ -28315,8 +28104,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
@@ -28328,8 +28117,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
@@ -28341,8 +28130,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,
@@ -28370,8 +28159,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>>*/ ;
@@ -28386,8 +28175,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>>*/ ;
@@ -28402,10 +28191,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
@@ -28646,11 +28434,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,
@@ -28736,8 +28519,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>>*/ }
@@ -28747,7 +28530,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;
@@ -28760,7 +28543,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){
@@ -28781,7 +28564,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){
@@ -28802,7 +28585,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]
@@ -28837,10 +28620,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 =
@@ -28937,19 +28720,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){
@@ -28998,7 +28783,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>>*/ ;
    }
@@ -29029,29 +28815,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
@@ -29061,8 +28847,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){
@@ -29096,7 +28882,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>>*/ ;
    }
@@ -29106,8 +28893,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:614:2>>*/ width$3;
@@ -29258,7 +29045,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)
@@ -29271,8 +29058,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),
@@ -29371,8 +29159,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
                -
@@ -29439,8 +29227,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,
@@ -29526,8 +29314,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
            -
@@ -29610,8 +29398,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){
@@ -29640,14 +29428,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>>*/ ;
       }
@@ -29681,14 +29469,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:
@@ -29796,8 +29584,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_;
@@ -29832,7 +29620,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)
@@ -29844,12 +29633,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);
@@ -29923,11 +29711,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>>*/ ;
@@ -29952,8 +29739,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{
@@ -29961,8 +29748,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;
@@ -30074,13 +29861,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:
@@ -30200,8 +29987,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,
@@ -30217,8 +30004,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,
@@ -30251,8 +30038,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
@@ -30277,8 +30064,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
@@ -30303,8 +30090,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
@@ -30329,8 +30116,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
@@ -30403,8 +30190,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
@@ -30417,8 +30204,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;
@@ -30439,8 +30226,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){
@@ -30465,28 +30252,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_;
         }
@@ -30503,24 +30290,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;
@@ -30533,8 +30320,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{
@@ -30543,16 +30330,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],
@@ -30615,8 +30402,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)
@@ -30625,8 +30412,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>>*/ ;
      }
     }
    }
@@ -30639,18 +30426,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];
@@ -30659,8 +30446,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>>*/ ;
@@ -30668,7 +30455,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]);
       /*<<scanf.ml:1465:27>>*/ try{
       var
        args$1 =  /*<<scanf.ml:1466:10>>*/ make_scanf(ib, fmt, readers),
@@ -30683,12 +30470,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>>*/ ;
      }
@@ -30755,8 +30542,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){
@@ -30774,20 +30561,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;
@@ -30884,11 +30671,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,
@@ -30931,11 +30713,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),
@@ -31001,8 +30783,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;
     }
@@ -31044,8 +30826,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_);
@@ -31069,8 +30851,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){
@@ -31085,8 +30867,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
@@ -31094,16 +30877,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_);
@@ -31117,8 +30900,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>>*/ ;
@@ -31128,8 +30911,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]);
@@ -31152,8 +30935,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]);
@@ -31166,12 +30949,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>>*/ ;
        },
@@ -31182,7 +30965,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],
@@ -31190,10 +30973,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_ =
@@ -31206,12 +30989,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>>*/ ;
        },
@@ -31301,8 +31084,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_);
@@ -31318,11 +31101,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] =
@@ -31338,7 +31121,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,
@@ -31367,8 +31150,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,
@@ -31381,14 +31164,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
@@ -31910,15 +31693,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
@@ -31944,8 +31728,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
@@ -32002,8 +31786,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");
@@ -32049,16 +31833,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,
@@ -32076,35 +31850,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
@@ -32269,38 +32043,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>>*/ ;
@@ -32308,25 +32083,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];
@@ -32340,15 +32116,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];
@@ -32358,16 +32134,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];
@@ -32413,8 +32189,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>>*/ ;
    }
@@ -32460,16 +32236,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)
@@ -32480,8 +32256,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>>*/ ;
@@ -32498,25 +32274,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
@@ -32549,7 +32325,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;
     }
@@ -32599,8 +32375,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>>*/ ;
              },
@@ -32617,13 +32393,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_;
@@ -32672,16 +32443,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);
@@ -32689,10 +32458,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);
@@ -32710,8 +32477,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){
@@ -33172,8 +32939,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>>*/ ;
@@ -33183,7 +32950,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 =
@@ -33378,7 +33145,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;
@@ -33393,7 +33160,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 =
@@ -33439,7 +33206,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){
@@ -33755,18 +33522,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] =
@@ -33800,18 +33567,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;
@@ -33827,8 +33594,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>>*/ ;
@@ -33836,8 +33603,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>>*/ ;
@@ -34009,7 +33776,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
@@ -34022,8 +33789,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)
@@ -34032,7 +33799,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;
@@ -34227,7 +33994,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
@@ -34240,8 +34007,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_);
          },
@@ -34252,7 +34019,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;
@@ -34531,7 +34298,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
@@ -34544,8 +34311,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_);
          },
@@ -34556,7 +34323,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;
@@ -34632,11 +34399,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,
@@ -34688,8 +34450,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;
@@ -34697,11 +34459,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;
     }
@@ -34714,8 +34476,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;
@@ -34735,11 +34497,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;
     }
@@ -34763,7 +34525,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);
@@ -34773,7 +34535,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);
@@ -34785,8 +34547,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
@@ -34796,12 +34557,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
@@ -34832,25 +34593,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){
@@ -34861,8 +34622,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;
@@ -34871,27 +34632,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
@@ -34961,7 +34722,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);
@@ -34971,7 +34732,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);
@@ -34981,7 +34742,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);
@@ -34991,8 +34752,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);
@@ -35019,17 +34779,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;
@@ -35045,13 +34806,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{
@@ -35067,13 +34828,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;
@@ -35089,7 +34850,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;
      }
@@ -35102,13 +34863,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>>*/ ;
@@ -35132,7 +34893,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_;
@@ -35140,14 +34901,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>>*/ ;
            },
@@ -35155,23 +34917,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){
@@ -35182,8 +34945,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;
@@ -35193,8 +34956,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_];
@@ -35203,20 +34966,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:
        {
@@ -35236,23 +34998,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
@@ -35284,13 +35046,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){
@@ -35301,7 +35064,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];
@@ -35373,22 +35136,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
@@ -35421,32 +35184,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 =
@@ -35462,8 +35220,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 =
@@ -35527,7 +35285,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){
@@ -36185,7 +35943,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";
@@ -36331,7 +36089,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";
@@ -36379,11 +36137,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,
@@ -36402,22 +36155,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){
@@ -36504,7 +36257,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 ffab80e375ec4cfa7539c66fa67d21c4816a0d3c 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 05/13] Changes

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

diff --git a/CHANGES.md b/CHANGES.md
index f08cfdd244..2d1903832d 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -48,6 +48,7 @@
 * Compiler/wasm: use type analysis to remove some unnecessary uses of JavasScript strict equality (#2040)
 * Compiler/wasm: use more precise environment types (#2041)
 * Compiler/wasm: optimize calls to statically known function (#2044)
+* Compiler: Propagate arity between compilation units (#1594)
 
 ## Bug fixes
 * Compiler: fix stack overflow issues with double translation (#1869)

From 35334d1c9d6943287d7dc71658a2bafdb7b7c77a 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 06/13] Compiler: propagate information during optcall
 optimiastion.

---
 compiler/lib/driver.ml       |  6 +++++-
 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, 26 insertions(+), 10 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index c237302744..2957d8cc97 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -68,6 +68,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) =
@@ -177,7 +178,10 @@ let effects_and_exact_calls
       p, trampolined_calls, in_cps, None, 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
diff --git a/compiler/lib/global_flow.ml b/compiler/lib/global_flow.ml
index d3eeb8f929..b4dcdbc98f 100644
--- a/compiler/lib/global_flow.ml
+++ b/compiler/lib/global_flow.ml
@@ -804,6 +804,10 @@ let get_unique_closure info f =
         | None -> None
         | Some kind -> kind)
 
+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 3d78b4373e..1eca38e567 100644
--- a/compiler/lib/global_flow.mli
+++ b/compiler/lib/global_flow.mli
@@ -80,6 +80,8 @@ type state =
 
 val f : fast:bool -> Code.program -> state * info
 
+val update_def : info -> Code.Var.t -> Code.expr -> unit
+
 val exact_call : info -> Var.t -> int -> bool
 
 val get_unique_closure : info -> Var.t -> Var.t option
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 b4aff36d5b24ded7cb57440ad9e7dbe0ba660921 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 07/13] Compiler: Specialze.f use shapes to compute arity

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

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 2957d8cc97..1ae65f94a6 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -67,7 +67,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
 
@@ -179,7 +179,10 @@ let effects_and_exact_calls
   | `Disabled | `Jspi ->
       let p =
         Specialize.f
-          ~function_arity:(fun f -> Global_flow.function_arity info 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
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

From 87c9102df73f6666a980cb3bfbe610ad1bf82a55 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 10 Jun 2025 14:55:18 +0200
Subject: [PATCH 08/13] Compiler: load shapes for cma.js and cmo.js

---
 compiler/lib/driver.ml   | 12 +++---
 compiler/lib/shape.ml    | 87 +++++++++++++++++++++++++++++++++++++---
 compiler/lib/shape.mli   |  2 +
 compiler/tests-full/dune |  4 --
 4 files changed, 89 insertions(+), 16 deletions(-)

diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 1ae65f94a6..45001ca757 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -23,8 +23,6 @@ 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
@@ -103,7 +101,7 @@ let ( +> ) f g x = g (f x)
 let map_fst5 f (x, y, z, t, u) = f x, y, z, t, u
 
 let collects_shapes ~shapes (p : Code.program) =
-  if debug_shapes () || shapes
+  if shapes
   then (
     let t = Timer.make () in
     let shapes = ref StringMap.empty in
@@ -729,17 +727,17 @@ let full ~standalone ~wrap_with_fun ~shapes ~profile ~link ~source_map ~formatte
     +> name_variables
     +> output formatter ~source_map ()
   in
-  let shapes = optimized_code.shapes in
+  let shapes_v = optimized_code.shapes in
   StringMap.iter
     (fun name shape ->
       Shape.Store.set ~name shape;
-      if debug_shapes ()
+      if shapes
       then
         Pretty_print.string
           formatter
           (Printf.sprintf "//# shape: %s:%s\n" name (Shape.to_string shape)))
-    shapes;
-  emit formatter optimized_code, shapes
+    shapes_v;
+  emit formatter optimized_code, shapes_v
 
 let full_no_source_map ~formatter ~shapes ~standalone ~wrap_with_fun ~profile ~link p =
   let (_ : Source_map.info * _) =
diff --git a/compiler/lib/shape.ml b/compiler/lib/shape.ml
index 764a1571e0..4aaea44710 100644
--- a/compiler/lib/shape.ml
+++ b/compiler/lib/shape.ml
@@ -64,6 +64,73 @@ let rec to_string (shape : t) =
         | Top -> ""
         | _ -> "->" ^ to_string res)
 
+let of_string (s : string) =
+  let pos = ref 0 in
+  let current () = s.[!pos] in
+  let next () = incr pos in
+  let parse_char c =
+    let c' = current () in
+    if Char.equal c c' then next () else assert false
+  in
+  let parse_char_opt c =
+    let c' = current () in
+    if Char.equal c c'
+    then (
+      next ();
+      true)
+    else false
+  in
+  let rec parse_int acc =
+    match current () with
+    | '0' .. '9' as c ->
+        let d = Char.code c - Char.code '0' in
+        let acc = (acc * 10) + d in
+        next ();
+        parse_int acc
+    | _ -> acc
+  in
+  let rec parse_shape () =
+    match current () with
+    | '[' ->
+        next ();
+        parse_block []
+    | 'N' ->
+        next ();
+        Top
+    | 'F' ->
+        next ();
+        parse_fun ()
+    | _ -> assert false
+  and parse_block acc =
+    match current () with
+    | ']' ->
+        next ();
+        Block (List.rev acc)
+    | _ -> (
+        let x = parse_shape () in
+        match current () with
+        | ',' ->
+            next ();
+            parse_block (x :: acc)
+        | ']' ->
+            next ();
+            Block (List.rev (x :: acc))
+        | _ -> assert false)
+  and parse_fun () =
+    let () = parse_char '(' in
+    let arity = parse_int 0 in
+    let () = parse_char ')' in
+    let pure = parse_char_opt '*' in
+    match current () with
+    | '-' ->
+        next ();
+        parse_char '>';
+        let res = parse_shape () in
+        Function { arity; pure; res }
+    | _ -> Function { arity; pure; res = Top }
+  in
+  parse_shape ()
+
 module Store = struct
   let ext = ".jsoo-shape"
 
@@ -82,11 +149,21 @@ module Store = struct
   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)
+    if String.equal m magic
+    then (
+      let shapes : (string * shape) list = Marshal.from_channel ic in
+      close_in ic;
+      List.iter shapes ~f:(fun (name, shape) -> set ~name shape))
+    else (
+      close_in ic;
+      let l = file_lines_bin fn in
+      List.iter l ~f:(fun s ->
+          match String.drop_prefix ~prefix:"//#shape: " s with
+          | None -> ()
+          | Some name_n_shape -> (
+              match String.lsplit2 name_n_shape ~on:':' with
+              | None -> ()
+              | Some (name, shape) -> set ~name (of_string shape))))
 
   let load ~name ~paths =
     if String.Hashtbl.mem t name
diff --git a/compiler/lib/shape.mli b/compiler/lib/shape.mli
index 180840f9d6..32f290e98f 100644
--- a/compiler/lib/shape.mli
+++ b/compiler/lib/shape.mli
@@ -28,6 +28,8 @@ type t =
 
 val to_string : t -> string
 
+val of_string : string -> t
+
 val equal : t -> t -> bool
 
 val merge : t -> t -> t
diff --git a/compiler/tests-full/dune b/compiler/tests-full/dune
index 67c542571f..6a2d63700b 100644
--- a/compiler/tests-full/dune
+++ b/compiler/tests-full/dune
@@ -11,8 +11,6 @@
    --debug
    var
    --debuginfo
-   --debug
-   shapes
    %{lib:stdlib:stdlib.cma}
    -o
    %{targets})))
@@ -50,8 +48,6 @@
    %{bin:js_of_ocaml}
    --pretty
    --debuginfo
-   --debug
-   shapes
    %{dep:shapes.cma}
    -o
    %{targets})))

From 67fb89bc6a5110c15ea27c7b7fda6ef2427e924f Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 10 Jun 2025 14:57:31 +0200
Subject: [PATCH 09/13] Test: test shapes with 5.3

---
 compiler/tests-full/dune                   | 12 +++++++++---
 compiler/tests-full/shapes.cma.expected.js | 13 +++++++++----
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/compiler/tests-full/dune b/compiler/tests-full/dune
index 6a2d63700b..b07e4076cf 100644
--- a/compiler/tests-full/dune
+++ b/compiler/tests-full/dune
@@ -42,7 +42,9 @@
 (rule
  (targets shapes.cma.js)
  (enabled_if
-  (= %{ocaml_version} "5.2.0"))
+  (and
+   (>= %{ocaml_version} "5.3")
+   (< %{ocaml_version} "5.4")))
  (action
   (run
    %{bin:js_of_ocaml}
@@ -55,7 +57,9 @@
 (rule
  (targets shapes.cma.output.js)
  (enabled_if
-  (= %{ocaml_version} "5.2.0"))
+  (and
+   (>= %{ocaml_version} "5.3")
+   (< %{ocaml_version} "5.4")))
  (action
   (with-stdout-to
    %{targets}
@@ -64,7 +68,9 @@
 (rule
  (alias runtest)
  (enabled_if
-  (= %{ocaml_version} "5.2.0"))
+  (and
+   (>= %{ocaml_version} "5.3")
+   (< %{ocaml_version} "5.4")))
  (action
   (diff shapes.cma.expected.js shapes.cma.output.js)))
 
diff --git a/compiler/tests-full/shapes.cma.expected.js b/compiler/tests-full/shapes.cma.expected.js
index 8aabd47fe3..736bf99039 100644
--- a/compiler/tests-full/shapes.cma.expected.js
+++ b/compiler/tests-full/shapes.cma.expected.js
@@ -16,7 +16,7 @@
   (globalThis){
    "use strict";
    var runtime = globalThis.jsoo_runtime;
-   function f(_a_, param){
+   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];
@@ -62,6 +62,11 @@
             ? 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(),
     Shapes_M2 = global_data.Shapes__M2,
@@ -72,14 +77,14 @@
             < caml_call1(Stdlib_Random[5], 2)
             ? Shapes_M1[1]
             : function
-             (_a_, param){
+             (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];
+    x =  /*<<compiler/tests-full/m3.ml:3:8>>*/ caml_call2(f(0), 0, 0),
+    Shapes_M3 =  /*<<compiler/tests-full/m3.ml:3:18>>*/ [0, f, x];
    runtime.caml_register_global(3, Shapes_M3, "Shapes__M3");
    return;
    /*<<?>>*/ }

From f1c6c2c1591e990da5091f5501ecf43c6135379d Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 10 Jun 2025 14:59:28 +0200
Subject: [PATCH 10/13] Compiler: remove --write-shape flag

---
 compiler/bin-js_of_ocaml/cmd_arg.ml  |  13 +-
 compiler/bin-js_of_ocaml/cmd_arg.mli |   1 -
 compiler/bin-js_of_ocaml/compile.ml  |  57 ++--
 compiler/lib/driver.ml               |   1 -
 compiler/lib/parse_bytecode.ml       |  18 +-
 compiler/lib/shape.ml                |  88 +-----
 compiler/lib/shape.mli               |   8 +-
 compiler/tests-compiler/gh747.ml     | 436 ++++++++++++++-------------
 compiler/tests-compiler/sourcemap.ml |  43 +--
 9 files changed, 281 insertions(+), 384 deletions(-)

diff --git a/compiler/bin-js_of_ocaml/cmd_arg.ml b/compiler/bin-js_of_ocaml/cmd_arg.ml
index 2b2d5b2ea6..ac0b2af78c 100644
--- a/compiler/bin-js_of_ocaml/cmd_arg.ml
+++ b/compiler/bin-js_of_ocaml/cmd_arg.ml
@@ -65,7 +65,6 @@ type t =
   ; 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
@@ -120,10 +119,6 @@ let options =
     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)]. "
@@ -328,8 +323,7 @@ let options =
       js_files
       keep_unit_names
       effects
-      shape_files
-      write_shape =
+      shape_files =
     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
@@ -401,7 +395,6 @@ let options =
       ; keep_unit_names
       ; effects
       ; shape_files
-      ; write_shape
       }
   in
   let t =
@@ -435,8 +428,7 @@ let options =
       $ js_files
       $ keep_unit_names
       $ effects
-      $ shape_files
-      $ write_shape)
+      $ shape_files)
   in
   Term.ret t
 
@@ -666,7 +658,6 @@ let options_runtime_only =
       ; 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 8be8344fb1..79780ec8e8 100644
--- a/compiler/bin-js_of_ocaml/cmd_arg.mli
+++ b/compiler/bin-js_of_ocaml/cmd_arg.mli
@@ -38,7 +38,6 @@ type t =
       ]
   ; 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 357fced377..6364f88776 100644
--- a/compiler/bin-js_of_ocaml/compile.ml
+++ b/compiler/bin-js_of_ocaml/compile.ml
@@ -54,15 +54,7 @@ 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, 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));
+    let sm = f ~standalone ~shapes:write_shape ~source_map (k, fmt) in
     match source_map, sm with
     | None, _ | _, None -> ()
     | Some { output_file = output; source_map; keep_empty }, Some sm ->
@@ -140,11 +132,6 @@ 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
@@ -170,7 +157,6 @@ let run
     ; 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
@@ -273,7 +259,7 @@ let run
       output_file =
     if check_sourcemap then check_debug one;
     let init_pseudo_fs = fs_external && standalone in
-    let sm =
+    let sm, shapes =
       match output_file with
       | `Stdout, formatter ->
           let instr =
@@ -326,6 +312,7 @@ let run
                   Driver.f' ~standalone ~link:`Needed ?profile ~wrap_with_fun pfs_fmt code));
           res
     in
+    StringMap.iter (fun name shape -> Shape.Store.set ~name shape) shapes;
     if times () then Format.eprintf "compilation: %a@." Timer.print t;
     sm
   in
@@ -398,7 +385,7 @@ let run
         { code; cmis = StringSet.empty; debug = Parse_bytecode.Debug.default_summary }
       in
       output_gen
-        ~write_shape
+        ~write_shape:false
         ~standalone:true
         ~custom_header
         ~build_info:(Build_info.create `Runtime)
@@ -415,7 +402,7 @@ let run
             ~shapes
             ~link:`All
             output_file
-          |> map_fst (sourcemap_of_info ~base:source_map_base))
+          |> sourcemap_of_info ~base:source_map_base)
   | (`Stdin | `File _) as bytecode ->
       let kind, ic, close_ic, include_dirs =
         match bytecode with
@@ -448,7 +435,7 @@ let run
           in
           if times () then Format.eprintf "  parsing: %a@." Timer.print t1;
           output_gen
-            ~write_shape
+            ~write_shape:false
             ~standalone:true
             ~custom_header
             ~build_info:(Build_info.create `Exe)
@@ -463,7 +450,7 @@ let run
                 ~source_map
                 ~link:(if linkall then `All else `Needed)
                 output_file
-              |> map_fst (sourcemap_of_info ~base:source_map_base))
+              |> sourcemap_of_info ~base:source_map_base)
       | `Cmo cmo ->
           let output_file =
             match output_file, keep_unit_names with
@@ -488,7 +475,7 @@ let run
           in
           if times () then Format.eprintf "  parsing: %a@." Timer.print t1;
           output_gen
-            ~write_shape
+            ~write_shape:true
             ~standalone:false
             ~custom_header
             ~build_info:(Build_info.create `Cmo)
@@ -497,17 +484,16 @@ let run
             (fun ~standalone ~shapes ~source_map output ->
               match include_runtime with
               | true ->
-                  let sm1, sh1 =
+                  let sm1 =
                     output_partial_runtime ~standalone ~shapes ~source_map output
                   in
-                  let sm2, sh2 =
+                  let sm2 =
                     output_partial cmo code ~standalone ~shapes ~source_map output
                   in
-                  ( sourcemap_of_infos ~base:source_map_base [ sm1; sm2 ]
-                  , merge_shape sh1 sh2 )
+                  sourcemap_of_infos ~base:source_map_base [ sm1; sm2 ]
               | false ->
                   output_partial cmo code ~standalone ~shapes ~source_map output
-                  |> map_fst (sourcemap_of_info ~base:source_map_base))
+                  |> sourcemap_of_info ~base:source_map_base)
       | `Cma cma when keep_unit_names ->
           (if include_runtime
            then
@@ -523,7 +509,7 @@ let run
                    failwith "use [-o dirname/] or remove [--keep-unit-names]"
              in
              output_gen
-               ~write_shape
+               ~write_shape:false
                ~standalone:false
                ~custom_header
                ~build_info:(Build_info.create `Runtime)
@@ -531,7 +517,7 @@ let run
                (`Name output_file)
                (fun ~standalone ~shapes ~source_map output ->
                  output_partial_runtime ~standalone ~shapes ~source_map output
-                 |> map_fst (sourcemap_of_info ~base:source_map_base)));
+                 |> sourcemap_of_info ~base:source_map_base));
           List.iter cma.lib_units ~f:(fun cmo ->
               let output_file =
                 match output_file with
@@ -560,7 +546,7 @@ let run
                   t1
                   (Ocaml_compiler.Cmo_format.name cmo);
               output_gen
-                ~write_shape
+                ~write_shape:true
                 ~standalone:false
                 ~custom_header
                 ~build_info:(Build_info.create `Cma)
@@ -568,7 +554,7 @@ let run
                 (`Name output_file)
                 (fun ~standalone ~shapes ~source_map output ->
                   output_partial ~standalone ~shapes ~source_map cmo code output
-                  |> map_fst (sourcemap_of_info ~base:source_map_base)))
+                  |> sourcemap_of_info ~base:source_map_base))
       | `Cma cma ->
           let f ~standalone ~shapes ~source_map output =
             (* Always compute shapes because it can be used by other units of the cma *)
@@ -599,20 +585,15 @@ let run
                       (Ocaml_compiler.Cmo_format.name cmo);
                   output_partial ~standalone ~shapes ~source_map cmo code output)
             in
-            let sm_and_shapes =
+            let sm =
               match runtime with
               | None -> units
               | Some x -> x :: units
             in
-            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 (List.map sm_and_shapes ~f:fst)
-            , shapes )
+            sourcemap_of_infos ~base:source_map_base sm
           in
           output_gen
-            ~write_shape
+            ~write_shape:true
             ~standalone:false
             ~custom_header
             ~build_info:(Build_info.create `Cma)
diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 45001ca757..7d514c74c0 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -730,7 +730,6 @@ let full ~standalone ~wrap_with_fun ~shapes ~profile ~link ~source_map ~formatte
   let shapes_v = optimized_code.shapes in
   StringMap.iter
     (fun name shape ->
-      Shape.Store.set ~name shape;
       if shapes
       then
         Pretty_print.string
diff --git a/compiler/lib/parse_bytecode.ml b/compiler/lib/parse_bytecode.ml
index 5a864d4979..6c2466ebf8 100644
--- a/compiler/lib/parse_bytecode.ml
+++ b/compiler/lib/parse_bytecode.ml
@@ -587,7 +587,6 @@ module State = struct
     ; 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 =
@@ -672,7 +671,7 @@ module State = struct
 
   let pop_handler state = { state with handlers = List.tl state.handlers }
 
-  let initial includes g immutable =
+  let initial g immutable =
     { accu = Unset
     ; stack = []
     ; env = [||]
@@ -681,7 +680,6 @@ module State = struct
     ; globals = g
     ; immutable
     ; module_or_not = Ident.Tbl.create 0
-    ; includes
     }
 
   let rec print_stack f l =
@@ -831,7 +829,7 @@ let get_global state instrs i =
             (match g.named_value.(i) with
             | None -> ()
             | Some name -> (
-                match Shape.Store.load ~name ~paths:state.includes with
+                match Shape.Store.load ~name with
                 | None -> ()
                 | Some shape -> Shape.State.assign x shape));
             x, state, instrs
@@ -2538,9 +2536,9 @@ type one =
   ; debug : Debug.summary
   }
 
-let parse_bytecode ~includes code globals debug_data =
+let parse_bytecode code globals debug_data =
   let immutable = Code.Var.Hashtbl.create 0 in
-  let state = State.initial includes globals immutable in
+  let state = State.initial globals immutable in
   Code.Var.reset ();
   let blocks', joins = Blocks.analyse code in
   Shape.State.reset ();
@@ -2725,7 +2723,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 ~includes code globals debug_data in
+  let p = parse_bytecode code globals debug_data in
   (* register predefined exception *)
   let body =
     List.fold_left predefined_exceptions ~init:[] ~f:(fun body (i, name) ->
@@ -2855,7 +2853,7 @@ let from_bytes ~prims ~debug (code : bytecode) =
     t
   in
   let globals = make_globals 0 [||] prims in
-  let p = parse_bytecode ~includes:[] code globals debug_data in
+  let p = parse_bytecode code globals debug_data in
   let gdata = Var.fresh_n "global_data" in
   let need_gdata = ref false in
   let find_name i =
@@ -2987,7 +2985,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);
@@ -2996,7 +2994,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 ~includes code globals debug_data in
+  let prog = parse_bytecode 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/shape.ml b/compiler/lib/shape.ml
index 4aaea44710..45d64e97d3 100644
--- a/compiler/lib/shape.ml
+++ b/compiler/lib/shape.ml
@@ -28,8 +28,6 @@ type t =
       ; res : t
       }
 
-type shape = t
-
 let rec equal a b =
   match a, b with
   | Top, Top -> true
@@ -132,89 +130,23 @@ let of_string (s : string) =
   parse_shape ()
 
 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 String.equal m magic
-    then (
-      let shapes : (string * shape) list = Marshal.from_channel ic in
-      close_in ic;
-      List.iter shapes ~f:(fun (name, shape) -> set ~name shape))
-    else (
-      close_in ic;
-      let l = file_lines_bin fn in
-      List.iter l ~f:(fun s ->
-          match String.drop_prefix ~prefix:"//#shape: " s with
-          | None -> ()
-          | Some name_n_shape -> (
-              match String.lsplit2 name_n_shape ~on:':' with
-              | None -> ()
-              | Some (name, shape) -> set ~name (of_string 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 ]
+    let l = file_lines_bin fn in
+    List.iter l ~f:(fun s ->
+        match String.drop_prefix ~prefix:"//#shape: " s with
+        | None -> ()
+        | Some name_n_shape -> (
+            match String.lsplit2 name_n_shape ~on:':' with
+            | None -> ()
+            | Some (name, shape) -> set ~name (of_string shape)))
+
+  let load ~name = if String.Hashtbl.mem t name then get ~name else None
 end
 
 module State = struct
diff --git a/compiler/lib/shape.mli b/compiler/lib/shape.mli
index 32f290e98f..926f70ada7 100644
--- a/compiler/lib/shape.mli
+++ b/compiler/lib/shape.mli
@@ -35,19 +35,13 @@ 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
+  val load : name:string -> t option
 end
 
 module State : sig
diff --git a/compiler/tests-compiler/gh747.ml b/compiler/tests-compiler/gh747.ml
index cddb3e7c30..c94af5cb4e 100644
--- a/compiler/tests-compiler/gh747.ml
+++ b/compiler/tests-compiler/gh747.ml
@@ -56,55 +56,56 @@ print_endline(String.make 1 "Ɋ".[0] ^ String.make 1 "Ɋ".[1]);;
       1:
       2: //# unitInfo: Provides: Test
       3: //# unitInfo: Requires: Stdlib, Stdlib__Random, Stdlib__String
-      4: (function
-      5:   (globalThis){
-      6:    "use strict";
-      7:    var
-      8:     runtime = globalThis.jsoo_runtime,
-      9:     caml_string_of_jsbytes = runtime.caml_string_of_jsbytes;
-     10:    function caml_call1(f, a0){
-     11:     return (f.l >= 0 ? f.l : f.l = f.length) === 1
-     12:             ? f(a0)
-     13:             : runtime.caml_call_gen(f, [a0]);
-     14:    }
-     15:    function caml_call2(f, a0, a1){
-     16:     return (f.l >= 0 ? f.l : f.l = f.length) === 2
-     17:             ? f(a0, a1)
-     18:             : runtime.caml_call_gen(f, [a0, a1]);
-     19:    }
-     20:    var
-     21:     global_data = runtime.caml_get_global_data(),
-     22:     greeting = caml_string_of_jsbytes("hello world"),
-     23:     greeting$0 = caml_string_of_jsbytes("hello world with unicode: \xc9\x8a"),
-     24:     Stdlib = global_data.Stdlib,
-     25:     Stdlib_Random = global_data.Stdlib__Random,
-     26:     Stdlib_String = global_data.Stdlib__String;
-     27:     /*<<test.ml:3:0>>*/ caml_call1(Stdlib[46], greeting);
-     28:     /*<<test.ml:5:0>>*/ caml_call1(Stdlib[46], greeting$0);
-     29:    var
-     30:     _a_ =  /*<<test.ml:7:47>>*/ caml_call1(Stdlib_Random[5], 30),
-     31:     unicodeLength =
-     32:        /*<<test.ml:7:34>>*/  /*<<test.ml:7:67>>*/ runtime.caml_ml_string_length
-     33:        ( /*<<test.ml:7:34>>*/ caml_call2(Stdlib_String[1], _a_, 105)),
-     34:     _b_ =  /*<<test.ml:8:56>>*/ caml_call1(Stdlib[33], unicodeLength),
-     35:     _c_ =
-     36:        /*<<test.ml:8:14>>*/ caml_call2
-     37:        (Stdlib[28],
-     38:         caml_string_of_jsbytes('String.length("\xc9\x8a") should be two:'),
-     39:         _b_);
-     40:     /*<<test.ml:8:0>>*/ caml_call1(Stdlib[46], _c_);
-     41:    var
-     42:     _d_ =  /*<<test.ml:9:39>>*/ caml_call2(Stdlib_String[1], 1, 138),
-     43:     _e_ =  /*<<test.ml:9:14>>*/ caml_call2(Stdlib_String[1], 1, 201),
-     44:     _f_ =  /*<<test.ml:9:13>>*/ caml_call2(Stdlib[28], _e_, _d_);
-     45:     /*<<test.ml:9:0>>*/ caml_call1(Stdlib[46], _f_);
-     46:    var Test =  /*<<test.ml:9:62>>*/ [0, greeting$0, unicodeLength];
-     47:    runtime.caml_register_global(8, Test, "Test");
-     48:    return;
-     49:    /*<<?>>*/ }
-     50:   (globalThis));
-     51:
-     52: //# sourceMappingURL=test.map
+      4: //# shape: Test:[N,N]
+      5: (function
+      6:   (globalThis){
+      7:    "use strict";
+      8:    var
+      9:     runtime = globalThis.jsoo_runtime,
+     10:     caml_string_of_jsbytes = runtime.caml_string_of_jsbytes;
+     11:    function caml_call1(f, a0){
+     12:     return (f.l >= 0 ? f.l : f.l = f.length) === 1
+     13:             ? f(a0)
+     14:             : runtime.caml_call_gen(f, [a0]);
+     15:    }
+     16:    function caml_call2(f, a0, a1){
+     17:     return (f.l >= 0 ? f.l : f.l = f.length) === 2
+     18:             ? f(a0, a1)
+     19:             : runtime.caml_call_gen(f, [a0, a1]);
+     20:    }
+     21:    var
+     22:     global_data = runtime.caml_get_global_data(),
+     23:     greeting = caml_string_of_jsbytes("hello world"),
+     24:     greeting$0 = caml_string_of_jsbytes("hello world with unicode: \xc9\x8a"),
+     25:     Stdlib = global_data.Stdlib,
+     26:     Stdlib_Random = global_data.Stdlib__Random,
+     27:     Stdlib_String = global_data.Stdlib__String;
+     28:     /*<<test.ml:3:0>>*/ caml_call1(Stdlib[46], greeting);
+     29:     /*<<test.ml:5:0>>*/ caml_call1(Stdlib[46], greeting$0);
+     30:    var
+     31:     _a_ =  /*<<test.ml:7:47>>*/ caml_call1(Stdlib_Random[5], 30),
+     32:     unicodeLength =
+     33:        /*<<test.ml:7:34>>*/  /*<<test.ml:7:67>>*/ runtime.caml_ml_string_length
+     34:        ( /*<<test.ml:7:34>>*/ caml_call2(Stdlib_String[1], _a_, 105)),
+     35:     _b_ =  /*<<test.ml:8:56>>*/ caml_call1(Stdlib[33], unicodeLength),
+     36:     _c_ =
+     37:        /*<<test.ml:8:14>>*/ caml_call2
+     38:        (Stdlib[28],
+     39:         caml_string_of_jsbytes('String.length("\xc9\x8a") should be two:'),
+     40:         _b_);
+     41:     /*<<test.ml:8:0>>*/ caml_call1(Stdlib[46], _c_);
+     42:    var
+     43:     _d_ =  /*<<test.ml:9:39>>*/ caml_call2(Stdlib_String[1], 1, 138),
+     44:     _e_ =  /*<<test.ml:9:14>>*/ caml_call2(Stdlib_String[1], 1, 201),
+     45:     _f_ =  /*<<test.ml:9:13>>*/ caml_call2(Stdlib[28], _e_, _d_);
+     46:     /*<<test.ml:9:0>>*/ caml_call1(Stdlib[46], _f_);
+     47:    var Test =  /*<<test.ml:9:62>>*/ [0, greeting$0, unicodeLength];
+     48:    runtime.caml_register_global(8, Test, "Test");
+     49:    return;
+     50:    /*<<?>>*/ }
+     51:   (globalThis));
+     52:
+     53: //# sourceMappingURL=test.map
     |}]
 
 let%expect_test _ =
@@ -221,175 +222,176 @@ end
       1:
       2: //# unitInfo: Provides: Test
       3: //# unitInfo: Requires: Stdlib__Printf
-      4: (function
-      5:   (globalThis){
-      6:    "use strict";
-      7:    var
-      8:     runtime = globalThis.jsoo_runtime,
-      9:     caml_string_of_jsbytes = runtime.caml_string_of_jsbytes;
-     10:    function caml_call2(f, a0, a1){
-     11:     return (f.l >= 0 ? f.l : f.l = f.length) === 2
-     12:             ? f(a0, a1)
-     13:             : runtime.caml_call_gen(f, [a0, a1]);
-     14:    }
-     15:    function caml_call3(f, a0, a1, a2){
-     16:     return (f.l >= 0 ? f.l : f.l = f.length) === 3
-     17:             ? f(a0, a1, a2)
-     18:             : runtime.caml_call_gen(f, [a0, a1, a2]);
-     19:    }
-     20:    function caml_call8(f, a0, a1, a2, a3, a4, a5, a6, a7){
-     21:     return (f.l >= 0 ? f.l : f.l = f.length) === 8
-     22:             ? f(a0, a1, a2, a3, a4, a5, a6, a7)
-     23:             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5, a6, a7]);
-     24:    }
-     25:    var
-     26:     global_data = runtime.caml_get_global_data(),
-     27:     cst = caml_string_of_jsbytes(""),
-     28:     partial = [4, 0, 0, 0, [12, 45, [4, 0, 0, 0, 0]]],
-     29:     Stdlib_Printf = global_data.Stdlib__Printf,
-     30:     executable_name =
-     31:        /*<<test.ml:14:22>>*/ runtime.caml_sys_executable_name(0),
-     32:     os_type =  /*<<test.ml:15:22>>*/ runtime.caml_sys_get_config(0)[1],
-     33:     backend_type =
-     34:        /*<<test.ml:15:34>>*/ [0, caml_string_of_jsbytes("js_of_ocaml")],
-     35:     unix = runtime.caml_sys_const_ostype_unix(0),
-     36:     win32 = runtime.caml_sys_const_ostype_win32(0),
-     37:     cygwin = runtime.caml_sys_const_ostype_cygwin(0),
-     38:     max_array_length = runtime.caml_sys_const_max_wosize(0),
-     39:     max_floatarray_length = max_array_length / 2 | 0,
-     40:     max_string_length = (4 * max_array_length | 0) - 1 | 0,
-     41:     Unhandled =
-     42:       [248,
-     43:        caml_string_of_jsbytes("Test.Unhandled"),
-     44:        runtime.caml_fresh_oo_id(0)],
-     45:     cst_Raised_at = caml_string_of_jsbytes("Raised at"),
-     46:     cst_Re_raised_at = caml_string_of_jsbytes("Re-raised at"),
-     47:     cst_Raised_by_primitive_operat =
-     48:       caml_string_of_jsbytes("Raised by primitive operation at"),
-     49:     cst_Called_from = caml_string_of_jsbytes("Called from"),
-     50:     cst_inlined = caml_string_of_jsbytes(" (inlined)"),
-     51:     _a_ =
-     52:       [0,
-     53:        [2,
-     54:         0,
-     55:         [12,
-     56:          32,
-     57:          [2,
-     58:           0,
-     59:           [11,
-     60:            caml_string_of_jsbytes(' in file "'),
-     61:            [2,
-     62:             0,
-     63:             [12,
-     64:              34,
-     65:              [2,
-     66:               0,
-     67:               [11,
-     68:                caml_string_of_jsbytes(", line "),
-     69:                [4,
-     70:                 0,
+      4: //# shape: Test:[N,N,[N],N,N,N,N,N,N,N,N,N,N,F(2),F(2),[F(4)]]
+      5: (function
+      6:   (globalThis){
+      7:    "use strict";
+      8:    var
+      9:     runtime = globalThis.jsoo_runtime,
+     10:     caml_string_of_jsbytes = runtime.caml_string_of_jsbytes;
+     11:    function caml_call2(f, a0, a1){
+     12:     return (f.l >= 0 ? f.l : f.l = f.length) === 2
+     13:             ? f(a0, a1)
+     14:             : runtime.caml_call_gen(f, [a0, a1]);
+     15:    }
+     16:    function caml_call3(f, a0, a1, a2){
+     17:     return (f.l >= 0 ? f.l : f.l = f.length) === 3
+     18:             ? f(a0, a1, a2)
+     19:             : runtime.caml_call_gen(f, [a0, a1, a2]);
+     20:    }
+     21:    function caml_call8(f, a0, a1, a2, a3, a4, a5, a6, a7){
+     22:     return (f.l >= 0 ? f.l : f.l = f.length) === 8
+     23:             ? f(a0, a1, a2, a3, a4, a5, a6, a7)
+     24:             : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5, a6, a7]);
+     25:    }
+     26:    var
+     27:     global_data = runtime.caml_get_global_data(),
+     28:     cst = caml_string_of_jsbytes(""),
+     29:     partial = [4, 0, 0, 0, [12, 45, [4, 0, 0, 0, 0]]],
+     30:     Stdlib_Printf = global_data.Stdlib__Printf,
+     31:     executable_name =
+     32:        /*<<test.ml:14:22>>*/ runtime.caml_sys_executable_name(0),
+     33:     os_type =  /*<<test.ml:15:22>>*/ runtime.caml_sys_get_config(0)[1],
+     34:     backend_type =
+     35:        /*<<test.ml:15:34>>*/ [0, caml_string_of_jsbytes("js_of_ocaml")],
+     36:     unix = runtime.caml_sys_const_ostype_unix(0),
+     37:     win32 = runtime.caml_sys_const_ostype_win32(0),
+     38:     cygwin = runtime.caml_sys_const_ostype_cygwin(0),
+     39:     max_array_length = runtime.caml_sys_const_max_wosize(0),
+     40:     max_floatarray_length = max_array_length / 2 | 0,
+     41:     max_string_length = (4 * max_array_length | 0) - 1 | 0,
+     42:     Unhandled =
+     43:       [248,
+     44:        caml_string_of_jsbytes("Test.Unhandled"),
+     45:        runtime.caml_fresh_oo_id(0)],
+     46:     cst_Raised_at = caml_string_of_jsbytes("Raised at"),
+     47:     cst_Re_raised_at = caml_string_of_jsbytes("Re-raised at"),
+     48:     cst_Raised_by_primitive_operat =
+     49:       caml_string_of_jsbytes("Raised by primitive operation at"),
+     50:     cst_Called_from = caml_string_of_jsbytes("Called from"),
+     51:     cst_inlined = caml_string_of_jsbytes(" (inlined)"),
+     52:     _a_ =
+     53:       [0,
+     54:        [2,
+     55:         0,
+     56:         [12,
+     57:          32,
+     58:          [2,
+     59:           0,
+     60:           [11,
+     61:            caml_string_of_jsbytes(' in file "'),
+     62:            [2,
+     63:             0,
+     64:             [12,
+     65:              34,
+     66:              [2,
+     67:               0,
+     68:               [11,
+     69:                caml_string_of_jsbytes(", line "),
+     70:                [4,
      71:                 0,
      72:                 0,
-     73:                 [11, caml_string_of_jsbytes(", characters "), partial]]]]]]]]]],
-     74:        caml_string_of_jsbytes
-     75:         ('%s %s in file "%s"%s, line %d, characters %d-%d')],
-     76:     _b_ =
-     77:       [0,
-     78:        [2, 0, [11, caml_string_of_jsbytes(" unknown location"), 0]],
-     79:        caml_string_of_jsbytes("%s unknown location")],
-     80:     _c_ = [0, [2, 0, [12, 10, 0]], caml_string_of_jsbytes("%s\n")],
-     81:     _d_ =
-     82:       [0,
-     83:        [11,
-     84:         caml_string_of_jsbytes
-     85:          ("(Program not linked with -g, cannot print stack backtrace)\n"),
-     86:         0],
-     87:        caml_string_of_jsbytes
-     88:         ("(Program not linked with -g, cannot print stack backtrace)\n")];
-     89:    function format_backtrace_slot(pos, slot){
-     90:     function info(is_raise){
-     91:       /*<<test.ml:46:4>>*/ return is_raise
-     92:              ? 0 === pos ? cst_Raised_at : cst_Re_raised_at
-     93:              : 0 === pos ? cst_Raised_by_primitive_operat : cst_Called_from /*<<test.ml:49:75>>*/ ;
-     94:     }
-     95:      /*<<test.ml:51:2>>*/ if(0 === slot[0]){
-     96:      var
-     97:       _g_ =  /*<<test.ml:58:6>>*/ slot[5],
-     98:       _h_ = slot[4],
-     99:       _i_ = slot[3],
-    100:       _j_ = slot[6] ? cst_inlined : cst,
-    101:       _k_ =  /*<<test.ml:59:14>>*/ slot[2],
-    102:       _l_ = slot[7],
-    103:       _m_ = info(slot[1]);
-    104:       /*<<test.ml:58:11>>*/ return [0,
-    105:              caml_call8
-    106:               (Stdlib_Printf[4], _a_, _m_, _l_, _k_, _j_, _i_, _h_, _g_)] /*<<test.ml:61:52>>*/ ;
-    107:     }
-    108:      /*<<test.ml:53:6>>*/ if(slot[1])  /*<<test.ml:54:50>>*/ return 0;
-    109:     var _n_ =  /*<<test.ml:56:51>>*/ info(0);
-    110:      /*<<test.ml:56:13>>*/ return [0, caml_call2(Stdlib_Printf[4], _b_, _n_)] /*<<test.ml:56:64>>*/ ;
-    111:     /*<<test.ml:61:52>>*/ }
-    112:    function print_exception_backtrace(outchan, backtrace){
-    113:      /*<<test.ml:64:2>>*/ if(! backtrace)
-    114:       /*<<test.ml:66:6>>*/ return caml_call2(Stdlib_Printf[1], outchan, _d_) /*<<test.ml:73:10>>*/ ;
-    115:     var
-    116:      a =  /*<<test.ml:64:2>>*/ backtrace[1],
-    117:      _e_ =  /*<<test.ml:69:6>>*/ a.length - 2 | 0,
-    118:      _f_ = 0;
-    119:     if(_e_ >= 0){
-    120:      var i = _f_;
-    121:      for(;;){
-    122:       var
-    123:        match =
-    124:           /*<<test.ml:70:38>>*/  /*<<test.ml:70:14>>*/ format_backtrace_slot
-    125:           (i,  /*<<test.ml:70:38>>*/ runtime.caml_check_bound(a, i)[i + 1]);
-    126:        /*<<test.ml:70:43>>*/ if(match){
-    127:        var str = match[1];
-    128:         /*<<test.ml:72:24>>*/ caml_call3(Stdlib_Printf[1], outchan, _c_, str);
-    129:       }
-    130:       var _g_ =  /*<<test.ml:70:43>>*/ i + 1 | 0;
-    131:       if(_e_ === i) break;
-    132:       i = _g_;
-    133:      }
-    134:     }
-    135:      /*<<test.ml:69:6>>*/ return 0;
-    136:     /*<<test.ml:73:10>>*/ }
-    137:    function compare(left, right, e1, e2){
-    138:      /*<<test.ml:77:35>>*/ if(0 === e1[0]){
-    139:      var v1 = e1[1];
-    140:      if(0 !== e2[0])  /*<<test.ml:80:23>>*/ return -1;
-    141:      var v2 =  /*<<test.ml:77:35>>*/ e2[1];
-    142:       /*<<test.ml:78:24>>*/ return caml_call2(left, v1, v2) /*<<test.ml:81:24>>*/ ;
-    143:     }
-    144:     var v1$0 =  /*<<test.ml:77:35>>*/ e1[1];
-    145:     if(0 === e2[0])  /*<<test.ml:81:23>>*/ return 1;
-    146:     var v2$0 =  /*<<test.ml:77:35>>*/ e2[1];
-    147:      /*<<test.ml:79:26>>*/ return caml_call2(right, v1$0, v2$0) /*<<test.ml:81:24>>*/ ;
-    148:    }
-    149:    var
-    150:     Either =  /*<<test.ml:15:34>>*/ [0, compare],
-    151:     Test =
-    152:       [0,
-    153:        executable_name,
-    154:        os_type,
-    155:        backend_type,
-    156:        0,
-    157:        32,
+     73:                 0,
+     74:                 [11, caml_string_of_jsbytes(", characters "), partial]]]]]]]]]],
+     75:        caml_string_of_jsbytes
+     76:         ('%s %s in file "%s"%s, line %d, characters %d-%d')],
+     77:     _b_ =
+     78:       [0,
+     79:        [2, 0, [11, caml_string_of_jsbytes(" unknown location"), 0]],
+     80:        caml_string_of_jsbytes("%s unknown location")],
+     81:     _c_ = [0, [2, 0, [12, 10, 0]], caml_string_of_jsbytes("%s\n")],
+     82:     _d_ =
+     83:       [0,
+     84:        [11,
+     85:         caml_string_of_jsbytes
+     86:          ("(Program not linked with -g, cannot print stack backtrace)\n"),
+     87:         0],
+     88:        caml_string_of_jsbytes
+     89:         ("(Program not linked with -g, cannot print stack backtrace)\n")];
+     90:    function format_backtrace_slot(pos, slot){
+     91:     function info(is_raise){
+     92:       /*<<test.ml:46:4>>*/ return is_raise
+     93:              ? 0 === pos ? cst_Raised_at : cst_Re_raised_at
+     94:              : 0 === pos ? cst_Raised_by_primitive_operat : cst_Called_from /*<<test.ml:49:75>>*/ ;
+     95:     }
+     96:      /*<<test.ml:51:2>>*/ if(0 === slot[0]){
+     97:      var
+     98:       _g_ =  /*<<test.ml:58:6>>*/ slot[5],
+     99:       _h_ = slot[4],
+    100:       _i_ = slot[3],
+    101:       _j_ = slot[6] ? cst_inlined : cst,
+    102:       _k_ =  /*<<test.ml:59:14>>*/ slot[2],
+    103:       _l_ = slot[7],
+    104:       _m_ = info(slot[1]);
+    105:       /*<<test.ml:58:11>>*/ return [0,
+    106:              caml_call8
+    107:               (Stdlib_Printf[4], _a_, _m_, _l_, _k_, _j_, _i_, _h_, _g_)] /*<<test.ml:61:52>>*/ ;
+    108:     }
+    109:      /*<<test.ml:53:6>>*/ if(slot[1])  /*<<test.ml:54:50>>*/ return 0;
+    110:     var _n_ =  /*<<test.ml:56:51>>*/ info(0);
+    111:      /*<<test.ml:56:13>>*/ return [0, caml_call2(Stdlib_Printf[4], _b_, _n_)] /*<<test.ml:56:64>>*/ ;
+    112:     /*<<test.ml:61:52>>*/ }
+    113:    function print_exception_backtrace(outchan, backtrace){
+    114:      /*<<test.ml:64:2>>*/ if(! backtrace)
+    115:       /*<<test.ml:66:6>>*/ return caml_call2(Stdlib_Printf[1], outchan, _d_) /*<<test.ml:73:10>>*/ ;
+    116:     var
+    117:      a =  /*<<test.ml:64:2>>*/ backtrace[1],
+    118:      _e_ =  /*<<test.ml:69:6>>*/ a.length - 2 | 0,
+    119:      _f_ = 0;
+    120:     if(_e_ >= 0){
+    121:      var i = _f_;
+    122:      for(;;){
+    123:       var
+    124:        match =
+    125:           /*<<test.ml:70:38>>*/  /*<<test.ml:70:14>>*/ format_backtrace_slot
+    126:           (i,  /*<<test.ml:70:38>>*/ runtime.caml_check_bound(a, i)[i + 1]);
+    127:        /*<<test.ml:70:43>>*/ if(match){
+    128:        var str = match[1];
+    129:         /*<<test.ml:72:24>>*/ caml_call3(Stdlib_Printf[1], outchan, _c_, str);
+    130:       }
+    131:       var _g_ =  /*<<test.ml:70:43>>*/ i + 1 | 0;
+    132:       if(_e_ === i) break;
+    133:       i = _g_;
+    134:      }
+    135:     }
+    136:      /*<<test.ml:69:6>>*/ return 0;
+    137:     /*<<test.ml:73:10>>*/ }
+    138:    function compare(left, right, e1, e2){
+    139:      /*<<test.ml:77:35>>*/ if(0 === e1[0]){
+    140:      var v1 = e1[1];
+    141:      if(0 !== e2[0])  /*<<test.ml:80:23>>*/ return -1;
+    142:      var v2 =  /*<<test.ml:77:35>>*/ e2[1];
+    143:       /*<<test.ml:78:24>>*/ return caml_call2(left, v1, v2) /*<<test.ml:81:24>>*/ ;
+    144:     }
+    145:     var v1$0 =  /*<<test.ml:77:35>>*/ e1[1];
+    146:     if(0 === e2[0])  /*<<test.ml:81:23>>*/ return 1;
+    147:     var v2$0 =  /*<<test.ml:77:35>>*/ e2[1];
+    148:      /*<<test.ml:79:26>>*/ return caml_call2(right, v1$0, v2$0) /*<<test.ml:81:24>>*/ ;
+    149:    }
+    150:    var
+    151:     Either =  /*<<test.ml:15:34>>*/ [0, compare],
+    152:     Test =
+    153:       [0,
+    154:        executable_name,
+    155:        os_type,
+    156:        backend_type,
+    157:        0,
     158:        32,
-    159:        unix,
-    160:        win32,
-    161:        cygwin,
-    162:        max_array_length,
-    163:        max_floatarray_length,
-    164:        max_string_length,
-    165:        Unhandled,
-    166:        format_backtrace_slot,
-    167:        print_exception_backtrace,
-    168:        Either];
-    169:    runtime.caml_register_global(12, Test, "Test");
-    170:    return;
-    171:    /*<<?>>*/ }
-    172:   (globalThis));
-    173:
-    174: //# sourceMappingURL=test.map
+    159:        32,
+    160:        unix,
+    161:        win32,
+    162:        cygwin,
+    163:        max_array_length,
+    164:        max_floatarray_length,
+    165:        max_string_length,
+    166:        Unhandled,
+    167:        format_backtrace_slot,
+    168:        print_exception_backtrace,
+    169:        Either];
+    170:    runtime.caml_register_global(12, Test, "Test");
+    171:    return;
+    172:    /*<<?>>*/ }
+    173:   (globalThis));
+    174:
+    175: //# sourceMappingURL=test.map
     |}]
diff --git a/compiler/tests-compiler/sourcemap.ml b/compiler/tests-compiler/sourcemap.ml
index 661911190f..03c5ac62c0 100644
--- a/compiler/tests-compiler/sourcemap.ml
+++ b/compiler/tests-compiler/sourcemap.ml
@@ -72,27 +72,28 @@ let%expect_test _ =
     $ 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
+      3: //# shape: Test:[F(1)*]
+      4: (function(globalThis){
+      5:    "use strict";
+      6:    var runtime = globalThis.jsoo_runtime;
+      7:    function id(x){return x;}
+      8:    var Test = [0, id];
+      9:    runtime.caml_register_global(0, Test, "Test");
+     10:    return;
+     11:   }
+     12:   (globalThis));
+     13:
+     14: //# sourceMappingURL=test.map
+    /builtin/blackbox.ml:1:0 -> 6:7
+    /builtin/blackbox.ml:1:0 -> 6:17
+    /builtin/blackbox.ml:1:0 -> 7:0
+    /builtin/blackbox.ml:1:0 -> 7:12
+    /builtin/blackbox.ml:1:0 -> 7:15
+    /dune-root/test.ml:1:11 -> 7:18
+    /dune-root/test.ml:1:12 -> 7:27
+    /dune-root/test.ml:1:12 -> 8:0
+    /dune-root/test.ml:1:12 -> 8:7
+    /builtin/blackbox.ml:1:0 -> 8:14
     |}]
 
 let%expect_test _ =

From acfe19674657526e21d46e67750990a27b6a357a Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 10 Jun 2025 15:55:36 +0200
Subject: [PATCH 11/13] Misc: Bump version to accomodate dune version check

---
 VERSION | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/VERSION b/VERSION
index 5fe6072304..dfda3e0b4f 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-6.0.1
+6.1.0

From 681827db4e4720063125cc9e8045e47835f1fa72 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Tue, 10 Jun 2025 19:52:07 +0200
Subject: [PATCH 12/13] Compiler: wasmoo support for shapes

---
 compiler/bin-wasm_of_ocaml/cmd_arg.ml  | 13 ++++-
 compiler/bin-wasm_of_ocaml/cmd_arg.mli |  1 +
 compiler/bin-wasm_of_ocaml/compile.ml  | 77 +++++++++++++++++++++-----
 compiler/lib-wasm/link.ml              |  1 +
 compiler/lib/driver.ml                 |  2 +
 compiler/lib/parse_bytecode.ml         |  3 +
 6 files changed, 80 insertions(+), 17 deletions(-)

diff --git a/compiler/bin-wasm_of_ocaml/cmd_arg.ml b/compiler/bin-wasm_of_ocaml/cmd_arg.ml
index c965736f7b..1dcce5b33d 100644
--- a/compiler/bin-wasm_of_ocaml/cmd_arg.ml
+++ b/compiler/bin-wasm_of_ocaml/cmd_arg.ml
@@ -63,6 +63,7 @@ type t =
   ; params : (string * string) list
   ; include_dirs : string list
   ; effects : Config.effects_backend
+  ; shape_files : string list
   }
 
 let options () =
@@ -78,6 +79,10 @@ let options () =
     let doc = "Compile the bytecode program [$(docv)]. " in
     Arg.(required & pos ~rev:true 0 (some string) None & info [] ~docv:"PROGRAM" ~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 profile =
     let doc = "Set optimization profile : [$(docv)]." in
     let profile =
@@ -140,7 +145,8 @@ let options () =
       output_file
       input_file
       runtime_files
-      effects =
+      effects
+      shape_files =
     let chop_extension s = try Filename.chop_extension s with Invalid_argument _ -> s in
     let output_file =
       let ext =
@@ -172,6 +178,7 @@ let options () =
       ; sourcemap_root
       ; sourcemap_don't_inline_content
       ; effects
+      ; shape_files
       }
   in
   let t =
@@ -189,7 +196,8 @@ let options () =
       $ output_file
       $ input_file
       $ runtime_files
-      $ effects)
+      $ effects
+      $ shape_files)
   in
   Term.ret t
 
@@ -270,6 +278,7 @@ let options_runtime_only () =
       ; sourcemap_root
       ; sourcemap_don't_inline_content
       ; effects
+      ; shape_files = []
       }
   in
   let t =
diff --git a/compiler/bin-wasm_of_ocaml/cmd_arg.mli b/compiler/bin-wasm_of_ocaml/cmd_arg.mli
index cb73999673..5f869ed796 100644
--- a/compiler/bin-wasm_of_ocaml/cmd_arg.mli
+++ b/compiler/bin-wasm_of_ocaml/cmd_arg.mli
@@ -32,6 +32,7 @@ type t =
   ; params : (string * string) list
   ; include_dirs : string list
   ; effects : Config.effects_backend
+  ; shape_files : string list
   }
 
 val options : unit -> t Cmdliner.Term.t
diff --git a/compiler/bin-wasm_of_ocaml/compile.ml b/compiler/bin-wasm_of_ocaml/compile.ml
index 8b9ee787df..9a11c79802 100644
--- a/compiler/bin-wasm_of_ocaml/compile.ml
+++ b/compiler/bin-wasm_of_ocaml/compile.ml
@@ -245,7 +245,15 @@ let generate_prelude ~out_file =
   @@ fun ch ->
   let code, uinfo = Parse_bytecode.predefined_exceptions () in
   let profile = Profile.O1 in
-  let Driver.{ program; variable_uses; in_cps; deadcode_sentinal; _ }, global_flow_data =
+  let ( Driver.
+          { program
+          ; variable_uses
+          ; in_cps
+          ; deadcode_sentinal
+          ; shapes = _
+          ; trampolined_calls = _
+          }
+      , global_flow_data ) =
     Driver.optimize_for_wasm ~profile ~shapes:false code
   in
   let context = Generate.start () in
@@ -328,6 +336,16 @@ let add_source_map sourcemap_don't_inline_content z opt_source_map =
                 ~name:(Link.source_name i j file)
                 ~contents:(Yojson.Basic.to_string (`String sm))))
 
+let merge_shape a b =
+  StringMap.union (fun _name s1 s2 -> if Shape.equal s1 s2 then Some s1 else None) a b
+
+let sexp_of_shapes s =
+  StringMap.bindings s
+  |> List.map ~f:(fun (name, shape) ->
+         Sexp.List [ Atom name; Atom (Shape.to_string shape) ])
+
+let string_of_shapes s = Sexp.List (sexp_of_shapes s) |> Sexp.to_string
+
 let run
     { Cmd_arg.common
     ; profile
@@ -341,11 +359,24 @@ let run
     ; sourcemap_root
     ; sourcemap_don't_inline_content
     ; effects
+    ; shape_files
     } =
   Config.set_target `Wasm;
   Jsoo_cmdline.Arg.eval common;
   Config.set_effects_backend effects;
   Generate.init ();
+  List.iter shape_files ~f:(fun s ->
+      let z = Zip.open_in s in
+      if Zip.has_entry z ~name:"shapes.sexp"
+      then
+        let s = Zip.read_entry z ~name:"shapes.sexp" in
+        match Sexp.from_string s with
+        | List l ->
+            List.iter l ~f:(function
+              | Sexp.List [ Atom name; Atom shape ] ->
+                  Shape.Store.set ~name (Shape.of_string shape)
+              | _ -> ())
+        | _ -> ());
   let output_file = fst output_file in
   if debug_mem () then Debug.start_profiling output_file;
   List.iter params ~f:(fun (s, v) -> Config.Param.set s v);
@@ -398,10 +429,18 @@ let run
     check_debug one;
     let code = one.code in
     let standalone = Option.is_none unit_name in
-    let Driver.{ program; variable_uses; in_cps; deadcode_sentinal; _ }, global_flow_data
-        =
-      Driver.optimize_for_wasm ~profile ~shapes:false code
+    let ( Driver.
+            { program
+            ; variable_uses
+            ; in_cps
+            ; deadcode_sentinal
+            ; shapes
+            ; trampolined_calls = _
+            }
+        , global_flow_data ) =
+      Driver.optimize_for_wasm ~profile ~shapes:true code
     in
+    StringMap.iter (fun name shape -> Shape.Store.set ~name shape) shapes;
     let context = Generate.start () in
     let toplevel_name, generated_js =
       Generate.f
@@ -423,7 +462,7 @@ let run
       Generate.output ch ~context;
       close_out ch);
     if times () then Format.eprintf "compilation: %a@." Timer.print t;
-    generated_js
+    generated_js, shapes
   in
   (if runtime_only
    then (
@@ -479,7 +518,7 @@ let run
           then Some (Filename.temp_file unit_name ".wasm.map")
           else None)
        @@ fun opt_tmp_map_file ->
-       let unit_data =
+       let unit_data, shapes =
          Fs.with_intermediate_file (Filename.temp_file unit_name ".wasm")
          @@ fun input_file ->
          opt_with
@@ -488,7 +527,7 @@ let run
             then Some (Filename.temp_file unit_name ".wasm.map")
             else None)
          @@ fun opt_input_sourcemap ->
-         let fragments =
+         let fragments, shapes =
            output
              code
              ~wat_file:
@@ -504,9 +543,9 @@ let run
            ~input_file
            ~output_file:tmp_wasm_file
            ();
-         { Link.unit_name; unit_info; fragments }
+         { Link.unit_name; unit_info; fragments }, shapes
        in
-       cont unit_data unit_name tmp_wasm_file opt_tmp_map_file
+       cont unit_data unit_name tmp_wasm_file opt_tmp_map_file shapes
      in
      (match kind with
      | `Exe ->
@@ -537,7 +576,7 @@ let run
            then Some (Filename.temp_file "code" ".wasm.map")
            else None
          in
-         let generated_js =
+         let generated_js, _shapes =
            output
              code
              ~unit_name:None
@@ -601,8 +640,9 @@ let run
          @@ fun tmp_output_file ->
          let z = Zip.open_out tmp_output_file in
          let compile_cmo' z cmo =
-           compile_cmo cmo (fun unit_data _ tmp_wasm_file opt_tmp_map_file ->
+           compile_cmo cmo (fun unit_data _ tmp_wasm_file opt_tmp_map_file shapes ->
                Zip.add_file z ~name:"code.wasm" ~file:tmp_wasm_file;
+               Zip.add_entry z ~name:"shapes.sexp" ~contents:(string_of_shapes shapes);
                add_source_map sourcemap_don't_inline_content z (`File opt_tmp_map_file);
                unit_data)
          in
@@ -618,8 +658,8 @@ let run
            List.fold_right
              ~f:(fun cmo cont l ->
                compile_cmo cmo
-               @@ fun unit_data unit_name tmp_wasm_file opt_tmp_map_file ->
-               cont ((unit_data, unit_name, tmp_wasm_file, opt_tmp_map_file) :: l))
+               @@ fun unit_data unit_name tmp_wasm_file opt_tmp_map_file shapes ->
+               cont ((unit_data, unit_name, tmp_wasm_file, opt_tmp_map_file, shapes) :: l))
              cma.lib_units
              ~init:(fun l ->
                Fs.with_intermediate_file (Filename.temp_file "wasm" ".wasm")
@@ -628,7 +668,7 @@ let run
                let source_map =
                  Wasm_link.f
                    (List.map
-                      ~f:(fun (_, _, file, opt_source_map) ->
+                      ~f:(fun (_, _, file, opt_source_map, _) ->
                         { Wasm_link.module_name = "OCaml"
                         ; file
                         ; code = None
@@ -641,10 +681,17 @@ let run
                    ~output_file:tmp_wasm_file
                in
                Zip.add_file z ~name:"code.wasm" ~file:tmp_wasm_file;
+               let shapes =
+                 List.fold_left
+                   ~init:StringMap.empty
+                   ~f:(fun acc (_, _, _, _, shapes) -> merge_shape acc shapes)
+                   l
+               in
+               Zip.add_entry z ~name:"shapes.sexp" ~contents:(string_of_shapes shapes);
                if enable_source_maps
                then
                  add_source_map sourcemap_don't_inline_content z (`Source_map source_map);
-               List.map ~f:(fun (unit_data, _, _, _) -> unit_data) l)
+               List.map ~f:(fun (unit_data, _, _, _, _) -> unit_data) l)
              []
          in
          Link.add_info z ~build_info:(Build_info.create `Cma) ~unit_data ();
diff --git a/compiler/lib-wasm/link.ml b/compiler/lib-wasm/link.ml
index f2c527323b..272cc19054 100644
--- a/compiler/lib-wasm/link.ml
+++ b/compiler/lib-wasm/link.ml
@@ -345,6 +345,7 @@ let info_from_sexp info =
   let build_info =
     info |> member "build_info" |> mandatory (single Build_info.from_sexp)
   in
+
   let predefined_exceptions =
     info
     |> member "predefined_exceptions"
diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml
index 7d514c74c0..b5bb3c1211 100644
--- a/compiler/lib/driver.ml
+++ b/compiler/lib/driver.ml
@@ -120,6 +120,8 @@ let collects_shapes ~shapes (p : Code.program) =
                   | Utf (Utf8 s) -> s
                 in
                 shapes := StringMap.add name block !shapes
+            | Code.Let (_, Prim (Extern "caml_set_global", [ Pc (String name); Pv block ]))
+              -> shapes := StringMap.add name block !shapes
             | _ -> ()))
       p.blocks;
     let map =
diff --git a/compiler/lib/parse_bytecode.ml b/compiler/lib/parse_bytecode.ml
index 6c2466ebf8..56d870704e 100644
--- a/compiler/lib/parse_bytecode.ml
+++ b/compiler/lib/parse_bytecode.ml
@@ -844,6 +844,9 @@ let get_global state instrs i =
                 let x, state = State.fresh_var state in
                 if debug_parser ()
                 then Format.printf "%a = get_global(%s)@." Var.print x name;
+                (match Shape.Store.load ~name with
+                | None -> ()
+                | Some shape -> Shape.State.assign x shape);
                 ( x
                 , state
                 , Let (x, Prim (Extern "caml_get_global", [ Pc (String name) ])) :: instrs

From 7034a9dec9b46b388bf72feb3abb53ca514529c4 Mon Sep 17 00:00:00 2001
From: Hugo Heuzard <hugo.heuzard@gmail.com>
Date: Wed, 18 Jun 2025 21:04:17 +0200
Subject: [PATCH 13/13] small cleanup

---
 compiler/lib-wasm/link.ml | 1 -
 compiler/lib/shape.ml     | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/compiler/lib-wasm/link.ml b/compiler/lib-wasm/link.ml
index 272cc19054..f2c527323b 100644
--- a/compiler/lib-wasm/link.ml
+++ b/compiler/lib-wasm/link.ml
@@ -345,7 +345,6 @@ let info_from_sexp info =
   let build_info =
     info |> member "build_info" |> mandatory (single Build_info.from_sexp)
   in
-
   let predefined_exceptions =
     info
     |> member "predefined_exceptions"
diff --git a/compiler/lib/shape.ml b/compiler/lib/shape.ml
index 45d64e97d3..9337f46819 100644
--- a/compiler/lib/shape.ml
+++ b/compiler/lib/shape.ml
@@ -45,7 +45,7 @@ let rec merge (u : t) (v : t) =
     , 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
+      if List.compare_lengths b1 b2 = 0 then Block (List.map2 b1 b2 ~f:merge) else Top
   | Top, _ | _, Top -> Top
   | Function _, Block _ | Block _, Function _ -> Top