diff --git a/CHANGES.md b/CHANGES.md index 5570328a49..cbe1489c7a 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -1,6 +1,7 @@ # Dev (2023-??-??) - ?? ## Features/Changes +* Compiler: global dead code elimination (Micah Cantor, #1503) * Compiler: change control-flow compilation strategy (#1496) * Compiler: Dead code elimination of unused references (#2076) * Compiler: reduce memory consumption (#1516) diff --git a/TODO.txt b/TODO.txt index c099243943..4df3b95cf8 100644 --- a/TODO.txt +++ b/TODO.txt @@ -12,10 +12,6 @@ Compiler optimizations - cross-function optimizations -- deadcode elimination inside blocks - (for instance, elimination of function which are defined in a - functor but are not used) - - should we rebind variables from a deeper level ? (only if used more than once...) diff --git a/compiler/lib/code.mli b/compiler/lib/code.mli index 53dacdb048..a0cf79c344 100644 --- a/compiler/lib/code.mli +++ b/compiler/lib/code.mli @@ -222,6 +222,10 @@ module Print : sig | Instr of (instr * loc) | Last of (last * loc) + val expr : Format.formatter -> expr -> unit + + val constant : Format.formatter -> constant -> unit + val var_list : Format.formatter -> Var.t list -> unit val instr : Format.formatter -> instr * loc -> unit diff --git a/compiler/lib/config.ml b/compiler/lib/config.ml index 95193f49c3..9385a063ba 100644 --- a/compiler/lib/config.ml +++ b/compiler/lib/config.ml @@ -58,6 +58,8 @@ module Flag = struct let deadcode = o ~name:"deadcode" ~default:true + let globaldeadcode = o ~name:"globaldeadcode" ~default:true + let shortvar = o ~name:"shortvar" ~default:true let compact = o ~name:"compact" ~default:true diff --git a/compiler/lib/config.mli b/compiler/lib/config.mli index ac1672bdef..e4c86d37b0 100644 --- a/compiler/lib/config.mli +++ b/compiler/lib/config.mli @@ -25,6 +25,8 @@ module Flag : sig val deadcode : unit -> bool + val globaldeadcode : unit -> bool + val optcall : unit -> bool val shortvar : unit -> bool diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml index b1c2b93b57..a291924c9d 100644 --- a/compiler/lib/driver.ml +++ b/compiler/lib/driver.ml @@ -97,6 +97,10 @@ let effects p = else p, (Code.Var.Set.empty : Effects.cps_calls) let exact_calls profile p = + let deadcode_sentinal = + (* If deadcode is disabled, this field is just fresh variable *) + Code.Var.fresh () + in if not (Config.Flag.effects ()) then let fast = @@ -105,8 +109,14 @@ let exact_calls profile p = | O1 | O2 -> true in let info = Global_flow.f ~fast p in - Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p - else p + let p = + if Config.Flag.globaldeadcode () && Config.Flag.deadcode () + then Global_deadcode.f p ~deadcode_sentinal info + else p + in + let p = Specialize.f ~function_arity:(fun f -> Global_flow.function_arity info f) p in + p, deadcode_sentinal + else p, deadcode_sentinal let print p = if debug () then Code.Print.program (fun _ _ -> "") p; @@ -175,7 +185,7 @@ let generate ~exported_runtime ~wrap_with_fun ~warn_on_unhandled_effect - ((p, live_vars), cps_calls) = + (((p, live_vars), cps_calls), deadcode_sentinal) = if times () then Format.eprintf "Start Generation...@."; let should_export = should_export wrap_with_fun in Generate.f @@ -185,6 +195,7 @@ let generate ~cps_calls ~should_export ~warn_on_unhandled_effect + ~deadcode_sentinal d let debug_linker = Debug.find "linker" @@ -579,8 +590,7 @@ let full ~standalone ~wrap_with_fun ~profile ~linkall ~source_map formatter d p | O2 -> o2 | O3 -> o3) +> exact_calls profile - +> effects - +> map_fst (Generate_closure.f +> deadcode') + +> map_fst (effects +> map_fst (Generate_closure.f +> deadcode')) in let emit = generate d ~exported_runtime ~wrap_with_fun ~warn_on_unhandled_effect:standalone diff --git a/compiler/lib/generate.ml b/compiler/lib/generate.ml index 9a7e075028..1d9280d95e 100644 --- a/compiler/lib/generate.ml +++ b/compiler/lib/generate.ml @@ -285,12 +285,14 @@ module Ctx = struct ; should_export : bool ; effect_warning : bool ref ; cps_calls : Effects.cps_calls + ; deadcode_sentinal : Var.t } let initial ~warn_on_unhandled_effect ~exported_runtime ~should_export + ~deadcode_sentinal blocks live cps_calls @@ -304,6 +306,7 @@ module Ctx = struct ; should_export ; effect_warning = ref (not warn_on_unhandled_effect) ; cps_calls + ; deadcode_sentinal } end @@ -444,7 +447,7 @@ let rec constant_rec ~ctx x level instrs = | Float_array a -> ( Mlvalue.Array.make ~tag:Obj.double_array_tag - ~args:(Array.to_list (Array.map a ~f:float_const)) + ~args:(Array.to_list (Array.map a ~f:(fun x -> J.Element (float_const x)))) , instrs ) | Int64 i -> let p = @@ -490,9 +493,9 @@ let rec constant_rec ~ctx x level instrs = let instrs = (J.variable_declaration [ J.V v, (js, J.N) ], J.N) :: instrs in - J.EVar (J.V v) :: acc, instrs - | _ -> js :: acc, instrs) - else List.rev l, instrs + J.Element (J.EVar (J.V v)) :: acc, instrs + | _ -> J.Element js :: acc, instrs) + else List.map ~f:(fun x -> J.Element x) (List.rev l), instrs in Mlvalue.Block.make ~tag ~args:l, instrs) | Int i -> int32 i, instrs @@ -1037,6 +1040,14 @@ let rec translate_expr ctx queue loc x e level : _ * J.statement_list = List.fold_right ~f:(fun x (args, prop, queue) -> let (prop', cx), queue = access_queue queue x in + let cx = + match cx with + | J.EVar (J.V v) -> + if Var.equal v ctx.deadcode_sentinal + then J.ElementHole + else J.Element cx + | _ -> J.Element cx + in cx :: args, or_p prop prop', queue) (Array.to_list a) ~init:([], const_p, queue) @@ -1133,6 +1144,9 @@ let rec translate_expr ctx queue loc x e level : _ * J.statement_list = let prim = Share.get_prim (runtime_fun ctx) name ctx.Ctx.share in prim, const_p, queue | Extern "%closure", _ -> assert false + | Extern "%undefined", [] -> + J.(EVar (ident (Utf8_string.of_string_exn "undefined"))), const_p, queue + | Extern "%undefined", _ -> assert false | Extern "%caml_js_opt_call", f :: o :: l -> let (pf, cf), queue = access_queue' ~ctx queue f in let (po, co), queue = access_queue' ~ctx queue o in @@ -1582,7 +1596,10 @@ and compile_conditional st queue ~fall_through last scope_stack : _ * _ = match last with | Return x -> let (_px, cx), queue = access_queue queue x in - true, flush_all queue [ J.Return_statement (Some cx), loc ] + let return_expr = + if Var.equal st.ctx.deadcode_sentinal x then None else Some cx + in + true, flush_all queue [ J.Return_statement return_expr, loc ] | Raise (x, k) -> let (_px, cx), queue = access_queue queue x in true, flush_all queue (throw_statement st.ctx cx k loc) @@ -1791,6 +1808,7 @@ let f ~cps_calls ~should_export ~warn_on_unhandled_effect + ~deadcode_sentinal debug = let t' = Timer.make () in let share = Share.get ~cps_calls ~alias_prims:exported_runtime p in @@ -1802,6 +1820,7 @@ let f ~warn_on_unhandled_effect ~exported_runtime ~should_export + ~deadcode_sentinal p.blocks live_vars cps_calls diff --git a/compiler/lib/generate.mli b/compiler/lib/generate.mli index 66053fdc2c..eaf1ab8f5e 100644 --- a/compiler/lib/generate.mli +++ b/compiler/lib/generate.mli @@ -25,6 +25,7 @@ val f : -> cps_calls:Effects.cps_calls -> should_export:bool -> warn_on_unhandled_effect:bool + -> deadcode_sentinal:Code.Var.t -> Parse_bytecode.Debug.t -> Javascript.program diff --git a/compiler/lib/global_deadcode.ml b/compiler/lib/global_deadcode.ml new file mode 100644 index 0000000000..f6ad5b7743 --- /dev/null +++ b/compiler/lib/global_deadcode.ml @@ -0,0 +1,443 @@ +(* Js_of_ocaml compiler + * http://www.ocsigen.org/js_of_ocaml/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, with linking exception; + * either version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + *) + +open Code +open Stdlib + +let debug = Debug.find "globaldeadcode" + +let times = Debug.find "times" + +(** Definition of a variable [x]. *) +type def = + | Expr of expr (** [x] is defined by an expression. *) + | Param (** [x] is a block or closure parameter. *) + +(** Liveness of a variable [x], forming a lattice structure. *) +type live = + | Top (** [x] is live and not a block. *) + | Live of IntSet.t (** [x] is a live block with a (non-empty) set of live fields. *) + | Dead (** [x] is dead. *) + +module G = Dgraph.Make_Imperative (Var) (Var.ISet) (Var.Tbl) + +module Domain = struct + type t = live + + let equal l1 l2 = + match l1, l2 with + | Top, Top | Dead, Dead -> true + | Live f1, Live f2 -> IntSet.equal f1 f2 + | Top, (Dead | Live _) | Live _, (Dead | Top) | Dead, (Live _ | Top) -> false + + let bot = Dead + + (** Join the liveness according to lattice structure. *) + let join l1 l2 = + match l1, l2 with + | _, Top | Top, _ -> Top + | Live f1, Live f2 -> Live (IntSet.union f1 f2) + | Dead, Live f | Live f, Dead -> Live f + | Dead, Dead -> Dead +end + +module Solver = G.Solver (Domain) + +let definitions prog = + let defs = Var.Tbl.make () Param in + let set_def x d = Var.Tbl.set defs x d in + Addr.Map.iter + (fun _ block -> + (* Add defs from block body *) + List.iter + ~f:(fun (i, _) -> + match i with + | Let (x, e) -> set_def x (Expr e) + | Assign (x, _) -> set_def x Param + | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> ()) + block.body) + prog.blocks; + defs + +let variable_may_escape x (global_info : Global_flow.info) = + match global_info.info_variable_may_escape.(Var.idx x) with + | Escape | Escape_constant -> true + | No -> false + +(** Type of variable usage. *) +type usage_kind = + | Compute (** variable y is used to compute x *) + | Propagate (** values of y propagate to x *) + +(** Compute the adjacency list for the dependency graph of given program. An edge between + variables [x] and [y] is marked [Compute] if [x] is used in the definition of [y]. It is marked + as [Propagate] if [x] is applied as a closure or block argument the parameter [y]. + + We use information from global flow to try to add edges between function calls and their return values + at known call sites. *) +let usages prog (global_info : Global_flow.info) : usage_kind Var.Map.t Var.Tbl.t = + let uses = Var.Tbl.make () Var.Map.empty in + let add_use kind x y = Var.Tbl.set uses y (Var.Map.add x kind (Var.Tbl.get uses y)) in + let add_arg_dep params args = + List.iter2 ~f:(fun x y -> add_use Propagate x y) params args + in + let add_cont_deps (pc, args) = + match try Some (Addr.Map.find pc prog.blocks) with Not_found -> None with + | Some block -> add_arg_dep block.params args + | None -> () (* Dead continuation *) + in + let add_expr_uses x e : unit = + match e with + | Apply { f; args; _ } -> + (match Var.Tbl.get global_info.info_approximation f with + | Top -> () + | Values { known; _ } -> + Var.Set.iter (* For each known closure value of f *) + (fun k -> + (* 1. Look at return values, and add edge between x and these values. *) + (* 2. Add an edge pairwise between the parameters and arguments *) + match global_info.info_defs.(Var.idx k) with + | Expr (Closure (params, _)) -> + (* If the function is under/over-applied then global flow will mark arguments and return value as escaping. + So we only need to consider the case when there is an exact application. *) + if List.compare_lengths params args = 0 + then ( + let return_values = Var.Map.find k global_info.info_return_vals in + Var.Set.iter (add_use Propagate x) return_values; + List.iter2 ~f:(add_use Propagate) params args) + | _ -> ()) + known); + add_use Compute x f; + List.iter + ~f:(fun a -> if variable_may_escape a global_info then add_use Compute x a) + args + | Block (_, vars, _) -> Array.iter ~f:(add_use Compute x) vars + | Field (z, _) -> add_use Compute x z + | Constant _ -> () + | Closure (_, cont) -> add_cont_deps cont + | Prim (_, args) -> + List.iter + ~f:(fun arg -> + match arg with + | Pv v -> add_use Compute x v + | Pc _ -> ()) + args + in + Addr.Map.iter + (fun _ block -> + (* Add uses from block body *) + List.iter + ~f:(fun (i, _) -> + match i with + | Let (x, e) -> add_expr_uses x e + (* For assignment, propagate liveness from new to old variable like a block parameter *) + | Assign (x, y) -> add_use Propagate x y + | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> ()) + block.body; + (* Add uses from block branch *) + match fst block.branch with + | Return _ | Raise _ | Stop -> () + | Branch cont -> add_cont_deps cont + | Cond (_, cont1, cont2) -> + add_cont_deps cont1; + add_cont_deps cont2 + | Switch (_, a) -> Array.iter ~f:add_cont_deps a + | Pushtrap (cont, _, cont_h, _) -> + add_cont_deps cont; + add_cont_deps cont_h + | Poptrap cont -> add_cont_deps cont) + prog.blocks; + uses + +(** Return the set of variables used in a given expression *) +let expr_vars e = + let vars = Var.Set.empty in + match e with + | Apply { f; args; _ } -> + let vars = Var.Set.add f vars in + List.fold_left ~f:(fun acc x -> Var.Set.add x acc) ~init:vars args + | Block (_, params, _) -> + Array.fold_left ~f:(fun acc x -> Var.Set.add x acc) ~init:vars params + | Field (z, _) -> Var.Set.add z vars + | Prim (_, args) -> + List.fold_left + ~f:(fun acc v -> + match v with + | Pv v -> Var.Set.add v vars + | Pc _ -> acc) + ~init:vars + args + (* We can ignore closures. We want the set of previously defined variables used + in the expression, so not parameters. The continuation may use some variables + but we will add these when we visit the body *) + | Constant _ | Closure (_, _) -> vars + +(** Compute the initial liveness of each variable in the program. + + A variable [x] is marked as [Top] if + + It is used in an impure expression (as defined by [Pure_fun.pure_expr]); + + It is used in a conditonal/switch; + + It is raised by an exception; + + It is used in another stateful instruction (like setting a block or array field); + + Or, it is returned or applied to a function and the global flow analysis marked it as escaping. + + A variable [x[i]] is marked as [Live {i}] if it is used in an instruction where field [i] is referenced or set. *) +let liveness prog pure_funs (global_info : Global_flow.info) = + let live_vars = Var.Tbl.make () Dead in + let add_top v = Var.Tbl.set live_vars v Top in + let add_live_field v i = + let live_fields = + match Var.Tbl.get live_vars v with + | Live fields -> Live (IntSet.add i fields) + | Top | Dead -> Live (IntSet.singleton i) + in + Var.Tbl.set live_vars v live_fields + in + let live_instruction i = + match i with + (* If e is impure, set all variables in e as Top. The only exception is for function applications, + where we may be able to do better. Global flow gives us information about which arguments in + a function application escape, so set only these as top. *) + | Let (_, e) -> ( + if not (Pure_fun.pure_expr pure_funs e) + then + match e with + | Apply { f; args; _ } -> + add_top f; + List.iter + ~f:(fun x -> if variable_may_escape x global_info then add_top x) + args + | Block (_, _, _) | Field (_, _) | Closure (_, _) | Constant _ | Prim (_, _) -> + let vars = expr_vars e in + Var.Set.iter add_top vars) + | Set_field (x, i, y) -> + add_live_field x i; + add_top y + | Array_set (x, y, z) -> + add_top x; + add_top y; + add_top z + | Offset_ref (x, _) -> add_live_field x 0 + (* Assignment can be ignored. Liveness of old variable is just propagated to new variable. See [usages]. *) + | Assign (_, _) -> () + in + let live_block block = + List.iter ~f:(fun (i, _) -> live_instruction i) block.body; + match fst block.branch with + | Return x -> if variable_may_escape x global_info then add_top x + | Raise (x, _) -> add_top x + | Cond (x, _, _) -> add_top x + | Switch (x, _) -> add_top x + | Stop | Branch _ | Poptrap _ | Pushtrap _ -> () + in + Addr.Map.iter (fun _ block -> live_block block) prog.blocks; + live_vars + +(* Returns the set of variables given a table of variables. *) +let variables deps = + let vars = Var.ISet.empty () in + Var.Tbl.iter (fun v _ -> Var.ISet.add vars v) deps; + vars + +(** Propagate liveness of the usages of a variable [x] to [x]. The liveness of [x] is + defined by joining its current liveness and the contribution of each vairable [y] + that uses [x]. *) +let propagate uses defs live_vars live_table x = + (* Variable [y] uses [x] either in its definition ([Compute]) or as a closure/block parameter + ([Propagate]). In the latter case, the contribution is simply the liveness of [y]. In the former, + the contribution depends on the liveness of [y] and its definition. *) + let contribution y usage_kind = + match usage_kind with + (* If x is used to compute y, we consider the liveness of y *) + | Compute -> ( + match Var.Tbl.get live_table y with + (* If y is dead, then x is dead. *) + | Dead -> Dead + (* If y is a live block, then x is the join of liveness fields that are x *) + | Live fields -> ( + match Var.Tbl.get defs y with + | Expr (Block (_, vars, _)) -> + let found = ref false in + Array.iteri + ~f:(fun i v -> + if Var.equal v x && IntSet.mem i fields then found := true) + vars; + if !found then Top else Dead + | Expr (Field (_, i)) -> Live (IntSet.singleton i) + | _ -> Top) + (* If y is top and y is a field access, x depends only on that field *) + | Top -> ( + match Var.Tbl.get defs y with + | Expr (Field (_, i)) -> Live (IntSet.singleton i) + | _ -> Top)) + (* If x is used as an argument for parameter y, then contribution is liveness of y *) + | Propagate -> Var.Tbl.get live_table y + in + Var.Map.fold + (fun y usage_kind live -> Domain.join (contribution y usage_kind) live) + (Var.Tbl.get uses x) + (Domain.join (Var.Tbl.get live_vars x) (Var.Tbl.get live_table x)) + +let solver vars uses defs live_vars = + let g = + { G.domain = vars + ; G.iter_children = (fun f x -> Var.Map.iter (fun y _ -> f y) (Var.Tbl.get uses x)) + } + in + Solver.f () (G.invert () g) (propagate uses defs live_vars) + +(** Replace each instance of a dead variable with a sentinal value. + Blocks that end in dead variables are compacted to the first live entry. + Dead variables are replaced when + + They appear in a dead field of a block; or + + They are returned; or + + They are applied to a function. + *) +let zero prog sentinal live_table = + let compact_vars vars = + let i = ref (Array.length vars - 1) in + while !i >= 0 && Var.equal vars.(!i) sentinal do + i := !i - 1 + done; + if !i + 1 < Array.length vars then Array.sub vars ~pos:0 ~len:(!i + 1) else vars + in + let is_live v = + match Var.Tbl.get live_table v with + | Dead -> false + | Top | Live _ -> true + in + let zero_var x = if is_live x then x else sentinal in + let zero_instr instr = + match instr with + | Let (x, e) -> ( + match e with + | Block (start, vars, is_array) -> ( + match Var.Tbl.get live_table x with + | Live fields -> + let vars = + Array.mapi + ~f:(fun i v -> if IntSet.mem i fields then v else sentinal) + vars + |> compact_vars + in + let e = Block (start, vars, is_array) in + Let (x, e) + | _ -> instr) + | Apply ap -> + let args = List.map ~f:zero_var ap.args in + Let (x, Apply { ap with args }) + | Field (_, _) | Closure (_, _) | Constant _ | Prim (_, _) -> instr) + | Assign (_, _) | Set_field (_, _, _) | Offset_ref (_, _) | Array_set (_, _, _) -> + instr + in + let zero_block block = + (* Analyze block instructions *) + let body = List.map ~f:(fun (instr, loc) -> zero_instr instr, loc) block.body in + (* Analyze branch *) + let branch = + (* Zero out return values in last instruction, otherwise do nothing. *) + match block.branch with + | Return x, loc -> Return (zero_var x), loc + | Raise (_, _), _ + | Stop, _ + | Branch _, _ + | Cond (_, _, _), _ + | Switch (_, _), _ + | Pushtrap (_, _, _, _), _ + | Poptrap _, _ -> block.branch + in + { block with body; branch } + in + let blocks = prog.blocks |> Addr.Map.map zero_block in + { prog with blocks } + +module Print = struct + let live_to_string = function + | Live fields -> + "live { " ^ IntSet.fold (fun i s -> s ^ Format.sprintf "%d " i) fields "" ^ "}" + | Top -> "top" + | Dead -> "dead" + + let print_uses uses = + Format.eprintf "Usages:\n"; + Var.Tbl.iter + (fun v ds -> + Format.eprintf "%a: { " Var.print v; + Var.Map.iter + (fun d k -> + Format.eprintf + "(%a, %s) " + Var.print + d + (match k with + | Compute -> "C" + | Propagate -> "P")) + ds; + Format.eprintf "}\n") + uses + + let print_liveness live_vars = + Format.eprintf "Liveness:\n"; + Var.Tbl.iter + (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l)) + live_vars + + let print_live_tbl live_table = + Format.eprintf "Liveness with dependencies:\n"; + Var.Tbl.iter + (fun v l -> Format.eprintf "%a: %s\n" Var.print v (live_to_string l)) + live_table +end + +(** Add a sentinal variable declaration to the IR. The fresh variable is assigned to `undefined`. *) +let add_sentinal p sentinal = + let undefined = Prim (Extern "%undefined", []) in + let instr, loc = Let (sentinal, undefined), noloc in + Code.prepend p [ instr, loc ] + +(** Run the liveness analysis and replace dead variables with the given sentinal. *) +let f p ~deadcode_sentinal global_info = + let t = Timer.make () in + (* Add sentinal variable *) + let p = add_sentinal p deadcode_sentinal in + (* Compute definitions *) + let defs = definitions p in + (* Compute usages *) + let uses = usages p global_info in + (* Compute initial liveness *) + let pure_funs = Pure_fun.f p in + let live_vars = liveness p pure_funs global_info in + (* Propagate liveness to dependencies *) + let vars = variables uses in + let live_table = solver vars uses defs live_vars in + (* Print debug info *) + if debug () + then ( + Format.eprintf "Before Zeroing:\n"; + Code.Print.program (fun _ _ -> "") p; + Print.print_liveness live_vars; + Print.print_uses uses; + Print.print_live_tbl live_table); + (* Zero out dead fields *) + let p = zero p deadcode_sentinal live_table in + if debug () + then ( + Format.printf "After Zeroing:\n"; + Code.Print.program (fun _ _ -> "") p); + if times () then Format.eprintf " deadcode dgraph.: %a@." Timer.print t; + p diff --git a/compiler/lib/global_deadcode.mli b/compiler/lib/global_deadcode.mli new file mode 100644 index 0000000000..0c44ef8d93 --- /dev/null +++ b/compiler/lib/global_deadcode.mli @@ -0,0 +1,37 @@ +(* Js_of_ocaml compiler + * http://www.ocsigen.org/js_of_ocaml/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, with linking exception; + * either version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + *) + +(** Global deadcode elimination pass. + +This module provides a global liveness analysis more powerful than +that found in [deadcode.ml]. In particular, this analysis annotates +blocks with the specific fields that are live. It also uses +[global_flow.ml] to determine the liveness of function return +values. It first computes an initial liveness of each variable by +traversing the program IR. Then it propagates this information to +the dependencies of each variable using a flow analysis +solver. Lastly it replaces dead variables with a sentinal zero +variable (the JS value `undefined`). + +Although this module does not perform any dead-code elimination +itself, it is designed to be used to identify and substitute dead +variables that are then removed by [deadcode.ml]. In particular it +allows for the elimination of unused functions defined in functors, +which the original deadcode elimination cannot. *) + +val f : Code.program -> deadcode_sentinal:Code.Var.t -> Global_flow.info -> Code.program diff --git a/compiler/lib/global_flow.ml b/compiler/lib/global_flow.ml index 6c9f673247..6707addfa4 100644 --- a/compiler/lib/global_flow.ml +++ b/compiler/lib/global_flow.ml @@ -554,6 +554,8 @@ type info = { info_defs : def array ; info_approximation : Domain.t Var.Tbl.t ; info_may_escape : Var.ISet.t + ; info_variable_may_escape : escape_status array + ; info_return_vals : Var.Set.t Var.Map.t } let f ~fast p = @@ -639,11 +641,17 @@ let f ~fast p = | No -> "n")) s) vars; + let info_variable_may_escape = variable_may_escape in let info_may_escape = Var.ISet.empty () in Array.iteri ~f:(fun i s -> if Poly.(s <> No) then Var.ISet.add info_may_escape (Var.of_idx i)) may_escape; - { info_defs = defs; info_approximation = approximation; info_may_escape } + { info_defs = defs + ; info_approximation = approximation + ; info_variable_may_escape + ; info_may_escape + ; info_return_vals = rets + } let exact_call info f n = match Var.Tbl.get info.info_approximation f with diff --git a/compiler/lib/global_flow.mli b/compiler/lib/global_flow.mli index 576f45f8b6..61f5dbfb6a 100644 --- a/compiler/lib/global_flow.mli +++ b/compiler/lib/global_flow.mli @@ -31,10 +31,17 @@ type approx = ; others : bool (* Whether other values are possible *) } +type escape_status = + | Escape + | Escape_constant (* Escapes but we know the value is not modified *) + | No + type info = { info_defs : def array ; info_approximation : approx Var.Tbl.t ; info_may_escape : Var.ISet.t + ; info_variable_may_escape : escape_status array + ; info_return_vals : Var.Set.t Var.Map.t } val f : fast:bool -> Code.program -> info diff --git a/compiler/lib/macro.ml b/compiler/lib/macro.ml index 8904d212ac..c9e9fb2047 100644 --- a/compiler/lib/macro.ml +++ b/compiler/lib/macro.ml @@ -47,7 +47,7 @@ class macro_mapper ~flags = let tag = Int32.to_int (J.Num.to_int32 tag) in let args = List.map args ~f:(function - | J.Arg e -> m#expression e + | J.Arg e -> J.Element (m#expression e) | J.ArgSpread _ -> assert false) in Mlvalue.Block.make ~tag ~args diff --git a/compiler/lib/mlvalue.ml b/compiler/lib/mlvalue.ml index 8b5de2ca7b..6752522408 100644 --- a/compiler/lib/mlvalue.ml +++ b/compiler/lib/mlvalue.ml @@ -35,10 +35,8 @@ let is_immediate e = type_of_is_number J.EqEqEq e module Block = struct let make ~tag ~args = - J.EArr - (List.map - ~f:(fun x -> J.Element x) - (J.ENum (J.Num.of_int32 (Int32.of_int tag)) :: args)) + let tag_elt = J.Element (J.ENum (J.Num.of_int32 (Int32.of_int tag))) in + J.EArr (tag_elt :: args) let tag e = J.EAccess (e, ANormal, zero) diff --git a/compiler/lib/mlvalue.mli b/compiler/lib/mlvalue.mli index c0595eac3b..a4d847783b 100644 --- a/compiler/lib/mlvalue.mli +++ b/compiler/lib/mlvalue.mli @@ -18,7 +18,7 @@ *) module Block : sig - val make : tag:int -> args:Javascript.expression list -> Javascript.expression + val make : tag:int -> args:Javascript.element list -> Javascript.expression val tag : Javascript.expression -> Javascript.expression @@ -26,7 +26,7 @@ module Block : sig end module Array : sig - val make : tag:int -> args:Javascript.expression list -> Javascript.expression + val make : tag:int -> args:Javascript.element list -> Javascript.expression val length : Javascript.expression -> Javascript.expression diff --git a/compiler/lib/primitive.ml b/compiler/lib/primitive.ml index 55f9e8d27a..b1a4a6adf5 100644 --- a/compiler/lib/primitive.ml +++ b/compiler/lib/primitive.ml @@ -73,7 +73,15 @@ let arity nm = Hashtbl.find arities (resolve nm) let has_arity nm a = try Hashtbl.find arities (resolve nm) = a with Not_found -> false -let is_pure nm = Poly.(kind nm <> `Mutator) +let is_pure nm = + match nm with + | "%undefined" + | "%closure" + | "%identity" + | "%direct_int_div" + | "%direct_int_mod" + | "%direct_int_mul" -> true + | _ -> Poly.(kind nm <> `Mutator) let exists p = Hashtbl.mem kinds p diff --git a/compiler/tests-compiler/direct_calls.ml b/compiler/tests-compiler/direct_calls.ml index 30fdcc82fd..a6148b9780 100644 --- a/compiler/tests-compiler/direct_calls.ml +++ b/compiler/tests-compiler/direct_calls.ml @@ -57,26 +57,26 @@ let%expect_test "direct calls without --enable effects" = [%expect {| function test1(param){ - function f(g, x){return caml_call1(g, x);} - var _d_ = 7; - f(function(x){return x + 1 | 0;}, _d_); - var _e_ = 4.; - f(function(x){return x * 2.;}, _e_); + function f(g, x){caml_call1(g, x); return;} + var _e_ = 7; + f(function(x){return x + 1 | 0;}, _e_); + var _f_ = 4.; + f(function(x){return x * 2.;}, _f_); return 0; } //end function test2(param){ - function f(g, x){return caml_call1(g, x);} - var _c_ = 7; - f(function(x){return x + 1 | 0;}, _c_); + function f(g, x){caml_call1(g, x); return;} + var _d_ = 7; + f(function(x){return x + 1 | 0;}, _d_); f(function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, cst_a); return 0; } //end function test3(x){ function F(symbol){function f(x){return x + 1 | 0;} return [0, f];} - var M1 = F([0]), M2 = F([0]), _b_ = M2[1].call(null, 2); - return [0, M1[1].call(null, 1), _b_]; + var M1 = F([0]), M2 = F([0]), _c_ = M2[1].call(null, 2); + return [0, M1[1].call(null, 1), _c_]; } //end function test4(x){ diff --git a/compiler/tests-compiler/dune.inc b/compiler/tests-compiler/dune.inc index 0a870892f6..beb52862db 100644 --- a/compiler/tests-compiler/dune.inc +++ b/compiler/tests-compiler/dune.inc @@ -404,6 +404,21 @@ (preprocess (pps ppx_expect))) +(library + ;; compiler/tests-compiler/global_deadcode.ml + (name global_deadcode_15) + (enabled_if true) + (modules global_deadcode) + (libraries js_of_ocaml_compiler unix str jsoo_compiler_expect_tests_helper) + (inline_tests + (enabled_if true) + (deps + (file %{project_root}/compiler/bin-js_of_ocaml/js_of_ocaml.exe) + (file %{project_root}/compiler/bin-jsoo_minify/jsoo_minify.exe))) + (flags (:standard -open Jsoo_compiler_expect_tests_helper)) + (preprocess + (pps ppx_expect))) + (library ;; compiler/tests-compiler/inlining.ml (name inlining_15) diff --git a/compiler/tests-compiler/gh1007.ml b/compiler/tests-compiler/gh1007.ml index 46eb031059..084225d871 100644 --- a/compiler/tests-compiler/gh1007.ml +++ b/compiler/tests-compiler/gh1007.ml @@ -347,7 +347,7 @@ end = struct let run () = for i = 0 to 4 do - ignore (even (i) : bool) + if even (i) then print_string "" done end @@ -386,7 +386,7 @@ let () = M.run () default: return 1 - (1 - even(1)); } }; - even(i); + if(even(i)) caml_call1(Stdlib[42], cst); var _a_ = i + 1 | 0; if(4 === i) return 0; var i = _a_; @@ -431,7 +431,7 @@ end = struct let run () = for i = 0 to 4 do - ignore (even (i) : bool) + if even (i) then print_string "" done; list_iter (fun f -> f ()) (list_rev !delayed) end @@ -495,7 +495,7 @@ let () = M.run () }, closures$0 = closures(i), even = closures$0[1]; - even(i); + if(even(i)) caml_call1(Stdlib[42], cst); var _e_ = i + 1 | 0; if(4 === i){ var _d_ = caml_call1(list_rev, delayed[1]); diff --git a/compiler/tests-compiler/gh1494.ml b/compiler/tests-compiler/gh1494.ml index fd646b38f2..17cab23faf 100644 --- a/compiler/tests-compiler/gh1494.ml +++ b/compiler/tests-compiler/gh1494.ml @@ -39,7 +39,7 @@ let () = [%expect {| function bug(param){ - var g = [0, function(x){return function(_c_){return _c_;};}]; + var g = [0, function(x){return function(_d_){return _d_;};}]; return [0, function(param){return caml_call1(g[1], 1);}, g]; } //end |}] diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml new file mode 100644 index 0000000000..d5ccec6b8a --- /dev/null +++ b/compiler/tests-compiler/global_deadcode.ml @@ -0,0 +1,132 @@ +open Util + +let%expect_test "Eliminates unused functions from functor" = + let program = + (* Create two instances of Set functor so compiler can't inline one implementation. *) + compile_and_parse_whole_program + {| + module Int_set = Set.Make (Int);; + module String_set = Set.Make (String);; + + let int_set = Int_set.singleton 1 in + let string_set = String_set.empty in + let string_set = String_set.add "hello" string_set in + print_endline (string_of_int (Int_set.find 1 int_set) ^ (String_set.find "hello" string_set)) + |} + in + let app = find_variable program "String_set" in + (let open Js_of_ocaml_compiler in + let open Stdlib in + match app with + | Javascript.ECall (EVar (S { name = Utf8 name; _ }), _, _, _) -> ( + let _, _, body, _ = find_function program name in + match List.rev body with + | (Return_statement (Some (EArr return)), loc) :: rest -> + let return = + ( Javascript.Return_statement + (Some + (EArr + (List.filter return ~f:(function + | Javascript.ElementHole -> false + | _ -> true)))) + , loc ) + in + print_program (List.rev (return :: rest)) + | _ -> ()) + | _ -> ()); + [%expect + {| + function height(param){if(! param) return 0; var h = param[4]; return h;} + function create(l, v, r){ + if(l) var h = l[4], hl = h; else var hl = 0; + if(r) var h$0 = r[4], hr = h$0; else var hr = 0; + var _n_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0; + return [0, l, v, r, _n_]; + } + function bal(l, v, r){ + if(l) var h = l[4], hl = h; else var hl = 0; + if(r) var h$0 = r[4], hr = h$0; else var hr = 0; + if((hr + 2 | 0) < hl){ + if(! l) return invalid_arg(_b_); + var lr = l[3], lv = l[2], ll = l[1], _i_ = height(lr); + if(_i_ <= height(ll)) return create(ll, lv, create(lr, v, r)); + if(! lr) return invalid_arg(_a_); + var lrr = lr[3], lrv = lr[2], lrl = lr[1], _j_ = create(lrr, v, r); + return create(create(ll, lv, lrl), lrv, _j_); + } + if((hl + 2 | 0) >= hr){ + var _m_ = hr <= hl ? hl + 1 | 0 : hr + 1 | 0; + return [0, l, v, r, _m_]; + } + if(! r) return invalid_arg(_d_); + var rr = r[3], rv = r[2], rl = r[1], _k_ = height(rl); + if(_k_ <= height(rr)) return create(create(l, v, rl), rv, rr); + if(! rl) return invalid_arg(_c_); + var rlr = rl[3], rlv = rl[2], rll = rl[1], _l_ = create(rlr, rv, rr); + return create(create(l, v, rll), rlv, _l_); + } + function add(x, t){ + if(! t) return [0, 0, x, 0, 1]; + var r = t[3], v = t[2], l = t[1], c = caml_call2(Ord[1], x, v); + if(0 === c) return t; + if(0 <= c){var rr = add(x, r); return r === rr ? t : bal(l, v, rr);} + var ll = add(x, l); + return l === ll ? t : bal(ll, v, r); + } + function singleton(x){return [0, 0, x, 0, 1];} + var empty = 0; + function find(x, param){ + var param$0 = param; + for(;;){ + if(! param$0) throw caml_maybe_attach_backtrace(Not_found, 1); + var + r = param$0[3], + v = param$0[2], + l = param$0[1], + c = caml_call2(Ord[1], x, v); + if(0 === c) return v; + var r$0 = 0 <= c ? r : l, param$0 = r$0; + } + } + return [0, empty, add, singleton, find]; + //end |}] + +let%expect_test "Omit unused fields" = + let program = + compile_and_parse + {| + let f b x = + let t = if b then (1, 2, x) else (3, x, 4) in + let (u, _, v) = t in + (u, v) + in print_int (fst (f true 1) + snd (f false 2)) + |} + in + (* Expect second field in each triple to be omitted. *) + print_fun_decl program (Some "f"); + [%expect + {| + function f(b, x){ + var t = b ? [0, 1, , x] : [0, 3, , 4], v = t[3], u = t[1]; + return [0, u, v]; + } + //end |}] + +let%expect_test "Omit unused return expressions" = + let program = + compile_and_parse + {| + let f x = + print_int x; + x + 1 + in + ignore (f 5 + f 6) + |} + in + (* Expect return value of f to be omitted. *) + print_fun_decl program (Some "f"); + [%expect + {| + function f(x){caml_call1(Stdlib[44], x); return;} + //end + |}] diff --git a/compiler/tests-compiler/util/util.ml b/compiler/tests-compiler/util/util.ml index 6ee6908049..428245646f 100644 --- a/compiler/tests-compiler/util/util.ml +++ b/compiler/tests-compiler/util/util.ml @@ -444,6 +444,14 @@ class find_variable_declaration r n = super#variable_declaration k v end +let find_variable program n = + let r = ref [] in + let o = new find_variable_declaration r n in + ignore (o#program program); + match !r with + | [ DeclIdent (_, Some (expression, _)) ] -> expression + | _ -> raise Not_found + let print_var_decl program n = let r = ref [] in let o = new find_variable_declaration r n in @@ -483,6 +491,14 @@ class find_function_declaration r n = let print_program p = print_string (program_to_string p) +let find_function program n = + let r = ref [] in + let o = new find_function_declaration r (Some n) in + ignore (o#program program); + match !r with + | [ (_, fd) ] -> fd + | _ -> raise Not_found + let print_fun_decl program n = let r = ref [] in let o = new find_function_declaration r n in diff --git a/compiler/tests-compiler/util/util.mli b/compiler/tests-compiler/util/util.mli index 5cdf488398..a8718910d2 100644 --- a/compiler/tests-compiler/util/util.mli +++ b/compiler/tests-compiler/util/util.mli @@ -71,6 +71,10 @@ val print_var_decl : Javascript.program -> string -> unit val print_fun_decl : Javascript.program -> string option -> unit +val find_variable : Javascript.program -> string -> Javascript.expression + +val find_function : Javascript.program -> string -> Javascript.function_declaration + val compile_and_run : ?debug:bool -> ?skip_modern:bool diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js index e95d98a6a6..859f00feef 100644 --- a/compiler/tests-full/stdlib.cma.expected.js +++ b/compiler/tests-full/stdlib.cma.expected.js @@ -1284,6 +1284,7 @@ Stdlib = global_data.Stdlib, Assert_failure = global_data.Assert_failure, Stdlib_Sys = global_data.Stdlib__Sys, + _b_ = undefined, cst_Obj_Ephemeron_blit_key = "Obj.Ephemeron.blit_key", cst_Obj_Ephemeron_check_key = "Obj.Ephemeron.check_key", cst_Obj_Ephemeron_unset_key = "Obj.Ephemeron.unset_key", @@ -1361,9 +1362,9 @@ max_ephe_length = Stdlib_Sys[13] - 2 | 0; function create(l){ /*<>*/ var - _g_ = 0 <= l ? 1 : 0, - _h_ = _g_ ? l <= max_ephe_length ? 1 : 0 : _g_; - if(1 - _h_) + _h_ = 0 <= l ? 1 : 0, + _i_ = _h_ ? l <= max_ephe_length ? 1 : 0 : _h_; + if(1 - _i_) /*<>*/ /*<>*/ caml_call1 (Stdlib[1], cst_Obj_Ephemeron_create); /*<>*/ return /*<>*/ runtime.caml_ephe_create @@ -1374,10 +1375,12 @@ /*<>*/ } function raise_if_invalid_offset(e, o, msg){ /*<>*/ var - _d_ = 0 <= o ? 1 : 0, - _e_ = _d_ ? o < length(e) ? 1 : 0 : _d_, - _f_ = 1 - _e_; - return _f_ ? /*<>*/ caml_call1(Stdlib[1], msg) : _f_; + _e_ = 0 <= o ? 1 : 0, + _f_ = _e_ ? o < length(e) ? 1 : 0 : _e_, + _g_ = 1 - _f_; + if(! _g_) return _g_; + /*<>*/ /*<>*/ caml_call1(Stdlib[1], msg); + /*<>*/ return; /*<>*/ } function get_key(e, o){ /*<>*/ raise_if_invalid_offset @@ -1416,13 +1419,13 @@ 0 <= o1 && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){ var - _b_ = 0 !== l ? 1 : 0, - _c_ = - _b_ + _c_ = 0 !== l ? 1 : 0, + _d_ = + _c_ ? /*<>*/ runtime.caml_ephe_blit_key (e1, o1, e2, o2, l) - : _b_; - /*<>*/ return _c_; + : _c_; + /*<>*/ return _d_; } /*<>*/ return /*<>*/ caml_call1 (Stdlib[1], cst_Obj_Ephemeron_blit_key); @@ -4970,6 +4973,7 @@ : runtime.caml_call_gen(f, [a0, a1]); } var + _g_ = undefined, global_data = runtime.caml_get_global_data(), Stdlib = global_data.Stdlib, Stdlib_Uchar = global_data.Stdlib__Uchar, @@ -5014,15 +5018,15 @@ function init(n, f){ /*<>*/ var /*<>*/ s = /*<>*/ caml_create_bytes(n), - /*<>*/ _aq_ = n - 1 | 0, - /*<>*/ _ap_ = 0; - if(_aq_ >= 0){ - var i = _ap_; + /*<>*/ _ar_ = n - 1 | 0, + /*<>*/ _aq_ = 0; + if(_ar_ >= 0){ + var i = _aq_; for(;;){ caml_bytes_unsafe_set(s, i, /*<>*/ caml_call1(f, i)); - /*<>*/ /*<>*/ var _ar_ = i + 1 | 0; - if(_aq_ === i) break; - var i = _ar_; + /*<>*/ /*<>*/ var _as_ = i + 1 | 0; + if(_ar_ === i) break; + var i = _as_; } } /*<>*/ return s; @@ -5064,11 +5068,11 @@ function symbol(a, b){ /*<>*/ var c = a + b | 0, - _ao_ = b < 0 ? 1 : 0, + _ap_ = b < 0 ? 1 : 0, match = c < 0 ? 1 : 0; a: { - if(a < 0){if(_ao_ && ! match) break a;} else if(! _ao_ && match) break a; + if(a < 0){if(_ap_ && ! match) break a;} else if(! _ap_ && match) break a; /*<>*/ return c; } /*<>*/ return /*<>*/ caml_call1 @@ -5131,32 +5135,32 @@ /*<>*/ } function iter(f, a){ /*<>*/ var - _am_ = caml_ml_bytes_length(a) - 1 | 0, - /*<>*/ _al_ = 0; - if(_am_ >= 0){ - var i = _al_; + _an_ = caml_ml_bytes_length(a) - 1 | 0, + /*<>*/ _am_ = 0; + if(_an_ >= 0){ + var i = _am_; for(;;){ /*<>*/ /*<>*/ caml_call1 (f, caml_bytes_unsafe_get(a, i)); - /*<>*/ /*<>*/ var _an_ = i + 1 | 0; - if(_am_ === i) break; - var i = _an_; + /*<>*/ /*<>*/ var _ao_ = i + 1 | 0; + if(_an_ === i) break; + var i = _ao_; } } return 0; /*<>*/ } function iteri(f, a){ /*<>*/ var - _aj_ = caml_ml_bytes_length(a) - 1 | 0, - /*<>*/ _ai_ = 0; - if(_aj_ >= 0){ - var i = _ai_; + _ak_ = caml_ml_bytes_length(a) - 1 | 0, + /*<>*/ _aj_ = 0; + if(_ak_ >= 0){ + var i = _aj_; for(;;){ /*<>*/ /*<>*/ caml_call2 (f, i, caml_bytes_unsafe_get(a, i)); - /*<>*/ /*<>*/ var _ak_ = i + 1 | 0; - if(_aj_ === i) break; - var i = _ak_; + /*<>*/ /*<>*/ var _al_ = i + 1 | 0; + if(_ak_ === i) break; + var i = _al_; } } return 0; @@ -5179,13 +5183,13 @@ param = tl; continue; } - var _ah_ = caml_ml_bytes_length(hd) + acc | 0; + var _ai_ = caml_ml_bytes_length(hd) + acc | 0; } else - var _ah_ = acc; + var _ai_ = acc; /*<>*/ var /*<>*/ dst = - /*<>*/ caml_create_bytes(_ah_), + /*<>*/ caml_create_bytes(_ai_), pos = pos$1, param$0 = l; for(;;){ @@ -5223,10 +5227,10 @@ /*<>*/ } function is_space(param){ /*<>*/ /*<>*/ var - _ag_ = param - 9 | 0; + _ah_ = param - 9 | 0; a: { - if(4 < _ag_ >>> 0){if(23 !== _ag_) break a;} else if(2 === _ag_) break a; + if(4 < _ah_ >>> 0){if(23 !== _ah_) break a;} else if(2 === _ah_) break a; /*<>*/ return 1; } /*<>*/ return 0; @@ -5250,10 +5254,10 @@ function unsafe_escape(s){ /*<>*/ var /*<>*/ n = [0, 0], - _$_ = caml_ml_bytes_length(s) - 1 | 0, - /*<>*/ ___ = 0; - if(_$_ >= 0){ - var i$0 = ___; + _aa_ = caml_ml_bytes_length(s) - 1 | 0, + /*<>*/ _$_ = 0; + if(_aa_ >= 0){ + var i$0 = _$_; for(;;){ var match = caml_bytes_unsafe_get(s, i$0); a: @@ -5263,12 +5267,12 @@ c: { if(32 <= match){ - var _ad_ = match - 34 | 0; - if(58 < _ad_ >>> 0){ - if(93 <= _ad_) break c; + var _ae_ = match - 34 | 0; + if(58 < _ae_ >>> 0){ + if(93 <= _ae_) break c; } - else if(56 < _ad_ - 1 >>> 0) break b; - var _ae_ = 1; + else if(56 < _ae_ - 1 >>> 0) break b; + var _af_ = 1; break a; } if(11 <= match){ @@ -5276,15 +5280,15 @@ } else if(8 <= match) break b; } - var _ae_ = 4; + var _af_ = 4; break a; } - var _ae_ = 2; + var _af_ = 2; } - n[1] = n[1] + _ae_ | 0; - /*<>*/ /*<>*/ var _af_ = i$0 + 1 | 0; - if(_$_ === i$0) break; - var i$0 = _af_; + n[1] = n[1] + _af_ | 0; + /*<>*/ /*<>*/ var _ag_ = i$0 + 1 | 0; + if(_aa_ === i$0) break; + var i$0 = _ag_; } } if(n[1] === caml_ml_bytes_length(s)) /*<>*/ return s; @@ -5292,10 +5296,10 @@ s$0 = /*<>*/ caml_create_bytes(n[1]); n[1] = 0; /*<>*/ var - _ab_ = caml_ml_bytes_length(s) - 1 | 0, - /*<>*/ _aa_ = 0; - if(_ab_ >= 0){ - var i = _aa_; + _ac_ = caml_ml_bytes_length(s) - 1 | 0, + /*<>*/ _ab_ = 0; + if(_ac_ >= 0){ + var i = _ab_; for(;;){ var c = caml_bytes_unsafe_get(s, i); a: @@ -5353,9 +5357,9 @@ caml_bytes_unsafe_set(s$0, n[1], c); } n[1]++; - /*<>*/ /*<>*/ var _ac_ = i + 1 | 0; - if(_ab_ === i) break; - var i = _ac_; + /*<>*/ /*<>*/ var _ad_ = i + 1 | 0; + if(_ac_ === i) break; + var i = _ad_; } } /*<>*/ return s$0; @@ -5370,18 +5374,18 @@ /*<>*/ var /*<>*/ r = /*<>*/ caml_create_bytes(l), - /*<>*/ _Y_ = l - 1 | 0, - /*<>*/ _X_ = 0; - if(_Y_ >= 0){ - var i = _X_; + /*<>*/ _Z_ = l - 1 | 0, + /*<>*/ _Y_ = 0; + if(_Z_ >= 0){ + var i = _Y_; for(;;){ caml_bytes_unsafe_set (r, i, /*<>*/ caml_call1(f, caml_bytes_unsafe_get(s, i))); - /*<>*/ /*<>*/ var _Z_ = i + 1 | 0; - if(_Y_ === i) break; - var i = _Z_; + /*<>*/ /*<>*/ var ___ = i + 1 | 0; + if(_Z_ === i) break; + var i = ___; } } /*<>*/ return r; @@ -5392,18 +5396,18 @@ /*<>*/ var /*<>*/ r = /*<>*/ caml_create_bytes(l), - /*<>*/ _V_ = l - 1 | 0, - /*<>*/ _U_ = 0; - if(_V_ >= 0){ - var i = _U_; + /*<>*/ _W_ = l - 1 | 0, + /*<>*/ _V_ = 0; + if(_W_ >= 0){ + var i = _V_; for(;;){ caml_bytes_unsafe_set (r, i, /*<>*/ caml_call2(f, i, caml_bytes_unsafe_get(s, i))); - /*<>*/ /*<>*/ var _W_ = i + 1 | 0; - if(_V_ === i) break; - var i = _W_; + /*<>*/ /*<>*/ var _X_ = i + 1 | 0; + if(_W_ === i) break; + var i = _X_; } } /*<>*/ return r; @@ -5411,17 +5415,17 @@ function fold_left(f, x, a){ /*<>*/ var /*<>*/ r = [0, x], - _S_ = caml_ml_bytes_length(a) - 1 | 0, - /*<>*/ _R_ = 0; - if(_S_ >= 0){ - var i = _R_; + _T_ = caml_ml_bytes_length(a) - 1 | 0, + /*<>*/ _S_ = 0; + if(_T_ >= 0){ + var i = _S_; for(;;){ r[1] = /*<>*/ caml_call2 (f, r[1], caml_bytes_unsafe_get(a, i)); - /*<>*/ /*<>*/ var _T_ = i + 1 | 0; - if(_S_ === i) break; - var i = _T_; + /*<>*/ /*<>*/ var _U_ = i + 1 | 0; + if(_T_ === i) break; + var i = _U_; } } return r[1]; @@ -5429,17 +5433,17 @@ function fold_right(f, a, x){ /*<>*/ var /*<>*/ r = [0, x], - /*<>*/ _P_ = + /*<>*/ _Q_ = /*<>*/ caml_ml_bytes_length(a) - 1 | 0; - if(_P_ >= 0){ - var i = _P_; + if(_Q_ >= 0){ + var i = _Q_; for(;;){ r[1] = /*<>*/ caml_call2 (f, caml_bytes_unsafe_get(a, i), r[1]); - /*<>*/ /*<>*/ var _Q_ = i - 1 | 0; + /*<>*/ /*<>*/ var _R_ = i - 1 | 0; if(0 === i) break; - var i = _Q_; + var i = _R_; } } return r[1]; @@ -5494,8 +5498,8 @@ /*<>*/ var len_s = caml_ml_bytes_length(s), len_pre = caml_ml_bytes_length(prefix), - _O_ = len_pre <= len_s ? 1 : 0; - if(! _O_) return _O_; + _P_ = len_pre <= len_s ? 1 : 0; + if(! _P_) return _P_; var i = 0; /*<>*/ for(;;){ if(i === len_pre) /*<>*/ return 1; @@ -5511,8 +5515,8 @@ len_s = caml_ml_bytes_length(s), len_suf = caml_ml_bytes_length(suffix), diff = len_s - len_suf | 0, - _N_ = 0 <= diff ? 1 : 0; - if(! _N_) return _N_; + _O_ = 0 <= diff ? 1 : 0; + if(! _O_) return _O_; var i = 0; /*<>*/ for(;;){ if(i === len_suf) /*<>*/ return 1; @@ -5611,13 +5615,13 @@ if(0 <= i && l >= i) /*<>*/ try{ /*<>*/ index_rec(s, l, i, c); - /*<>*/ /*<>*/ var _L_ = 1; - /*<>*/ return _L_; + /*<>*/ /*<>*/ var _M_ = 1; + /*<>*/ return _M_; } - catch(_M_){ - var _K_ = caml_wrap_exception(_M_); - if(_K_ === Stdlib[8]) /*<>*/ return 0; - throw caml_maybe_attach_backtrace(_K_, 0); + catch(_N_){ + var _L_ = caml_wrap_exception(_N_); + if(_L_ === Stdlib[8]) /*<>*/ return 0; + throw caml_maybe_attach_backtrace(_L_, 0); } /*<>*/ return /*<>*/ caml_call1 (Stdlib[1], cst_String_contains_from_Bytes); @@ -5629,13 +5633,13 @@ /*<>*/ if(0 <= i && caml_ml_bytes_length(s) > i) /*<>*/ try{ /*<>*/ rindex_rec(s, i, c); - /*<>*/ /*<>*/ var _I_ = 1; - /*<>*/ return _I_; + /*<>*/ /*<>*/ var _J_ = 1; + /*<>*/ return _J_; } - catch(_J_){ - var _H_ = caml_wrap_exception(_J_); - if(_H_ === Stdlib[8]) /*<>*/ return 0; - throw caml_maybe_attach_backtrace(_H_, 0); + catch(_K_){ + var _I_ = caml_wrap_exception(_K_); + if(_I_ === Stdlib[8]) /*<>*/ return 0; + throw caml_maybe_attach_backtrace(_I_, 0); } /*<>*/ return /*<>*/ caml_call1 (Stdlib[1], cst_String_rcontains_from_Byte); @@ -5646,23 +5650,23 @@ /*<>*/ r = [0, 0], /*<>*/ j = [0, /*<>*/ caml_ml_bytes_length(s)], - /*<>*/ _D_ = + /*<>*/ _E_ = /*<>*/ caml_ml_bytes_length(s) - 1 | 0; - if(_D_ >= 0){ - var i = _D_; + if(_E_ >= 0){ + var i = _E_; for(;;){ if(caml_bytes_unsafe_get(s, i) === sep){ - var _F_ = r[1]; - r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _F_]; + var _G_ = r[1]; + r[1] = [0, sub(s, i + 1 | 0, (j[1] - i | 0) - 1 | 0), _G_]; j[1] = i; } - /*<>*/ /*<>*/ var _G_ = i - 1 | 0; + /*<>*/ /*<>*/ var _H_ = i - 1 | 0; if(0 === i) break; - var i = _G_; + var i = _H_; } } - var _E_ = r[1]; - /*<>*/ return [0, sub(s, 0, j[1]), _E_]; + var _F_ = r[1]; + /*<>*/ return [0, sub(s, 0, j[1]), _F_]; /*<>*/ } function to_seq(s){ function aux(i, param){ @@ -5671,14 +5675,14 @@ /*<>*/ var /*<>*/ x = /*<>*/ caml_bytes_get(s, i), - /*<>*/ _B_ = i + 1 | 0; + /*<>*/ _C_ = i + 1 | 0; /*<>*/ return [0, x, - function(_C_){ /*<>*/ return aux(_B_, _C_);}]; + function(_D_){ /*<>*/ return aux(_C_, _D_);}]; /*<>*/ } - /*<>*/ /*<>*/ var _z_ = 0; - /*<>*/ return function(_A_){ - /*<>*/ return aux(_z_, _A_);}; + /*<>*/ /*<>*/ var _A_ = 0; + /*<>*/ return function(_B_){ + /*<>*/ return aux(_A_, _B_);}; /*<>*/ } function to_seqi(s){ function aux(i, param){ @@ -5687,20 +5691,20 @@ /*<>*/ var /*<>*/ x = /*<>*/ caml_bytes_get(s, i), - /*<>*/ _x_ = i + 1 | 0; + /*<>*/ _y_ = i + 1 | 0; /*<>*/ return [0, [0, i, x], - function(_y_){ /*<>*/ return aux(_x_, _y_);}]; + function(_z_){ /*<>*/ return aux(_y_, _z_);}]; /*<>*/ } - /*<>*/ /*<>*/ var _v_ = 0; - /*<>*/ return function(_w_){ - /*<>*/ return aux(_v_, _w_);}; + /*<>*/ /*<>*/ var _w_ = 0; + /*<>*/ return function(_x_){ + /*<>*/ return aux(_w_, _x_);}; /*<>*/ } function of_seq(i){ /*<>*/ var /*<>*/ n = [0, 0], /*<>*/ buf = [0, make(256, 0)]; - function _u_(c){ + function _v_(c){ /*<>*/ if(n[1] === caml_ml_bytes_length(buf[1])){ /*<>*/ /*<>*/ var new_len = @@ -5722,7 +5726,7 @@ return 0; /*<>*/ } /*<>*/ /*<>*/ caml_call2 - (Stdlib_Seq[4], _u_, i); + (Stdlib_Seq[4], _v_, i); return sub(buf[1], 0, n[1]); /*<>*/ } function unsafe_get_uint16_le(b, i){ @@ -5739,9 +5743,9 @@ /*<>*/ } function get_int8(b, i){ /*<>*/ var - /*<>*/ _s_ = Stdlib_Sys[10] - 8 | 0, - _t_ = Stdlib_Sys[10] - 8 | 0; - return /*<>*/ caml_bytes_get(b, i) << _t_ >> _s_; + /*<>*/ _t_ = Stdlib_Sys[10] - 8 | 0, + _u_ = Stdlib_Sys[10] - 8 | 0; + return /*<>*/ caml_bytes_get(b, i) << _u_ >> _t_; /*<>*/ } function get_uint16_le(b, i){ /*<>*/ return Stdlib_Sys[11] @@ -5757,21 +5761,21 @@ /*<>*/ } function get_int16_ne(b, i){ /*<>*/ var - /*<>*/ _q_ = Stdlib_Sys[10] - 16 | 0, - _r_ = Stdlib_Sys[10] - 16 | 0; - return /*<>*/ caml_bytes_get16(b, i) << _r_ >> _q_; + /*<>*/ _r_ = Stdlib_Sys[10] - 16 | 0, + _s_ = Stdlib_Sys[10] - 16 | 0; + return /*<>*/ caml_bytes_get16(b, i) << _s_ >> _r_; /*<>*/ } function get_int16_le(b, i){ /*<>*/ var - /*<>*/ _o_ = Stdlib_Sys[10] - 16 | 0, - _p_ = Stdlib_Sys[10] - 16 | 0; - return get_uint16_le(b, i) << _p_ >> _o_; + /*<>*/ _p_ = Stdlib_Sys[10] - 16 | 0, + _q_ = Stdlib_Sys[10] - 16 | 0; + return get_uint16_le(b, i) << _q_ >> _p_; /*<>*/ } function get_int16_be(b, i){ /*<>*/ var - /*<>*/ _m_ = Stdlib_Sys[10] - 16 | 0, - _n_ = Stdlib_Sys[10] - 16 | 0; - return get_uint16_be(b, i) << _n_ >> _m_; + /*<>*/ _n_ = Stdlib_Sys[10] - 16 | 0, + _o_ = Stdlib_Sys[10] - 16 | 0; + return get_uint16_be(b, i) << _o_ >> _n_; /*<>*/ } function get_int32_le(b, i){ /*<>*/ return Stdlib_Sys[11] @@ -5798,14 +5802,22 @@ ( /*<>*/ caml_bytes_get64(b, i)); /*<>*/ } function unsafe_set_uint16_le(b, i, x){ - /*<>*/ return Stdlib_Sys[11] - ? /*<>*/ caml_bytes_set16(b, i, caml_bswap16(x)) - : /*<>*/ caml_bytes_set16(b, i, x); + /*<>*/ if(Stdlib_Sys[11]){ + /*<>*/ /*<>*/ caml_bytes_set16 + (b, i, caml_bswap16(x)); + /*<>*/ return; + } + /*<>*/ /*<>*/ caml_bytes_set16(b, i, x); + /*<>*/ return; /*<>*/ } function unsafe_set_uint16_be(b, i, x){ - /*<>*/ return Stdlib_Sys[11] - ? /*<>*/ caml_bytes_set16(b, i, x) - : /*<>*/ caml_bytes_set16(b, i, caml_bswap16(x)); + /*<>*/ if(Stdlib_Sys[11]){ + /*<>*/ /*<>*/ caml_bytes_set16(b, i, x); + /*<>*/ return; + } + /*<>*/ /*<>*/ caml_bytes_set16 + (b, i, caml_bswap16(x)); + /*<>*/ return; /*<>*/ } function set_int16_le(b, i, x){ /*<>*/ return Stdlib_Sys[11] @@ -5847,9 +5859,9 @@ dec_invalid = Stdlib_Uchar[22]; function dec_ret(n, u){ /*<>*/ /*<>*/ var - _l_ = /*<>*/ caml_call1(Stdlib_Uchar[9], u); + _m_ = /*<>*/ caml_call1(Stdlib_Uchar[9], u); /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Uchar[21], n, _l_); + (Stdlib_Uchar[21], n, _m_); /*<>*/ } function not_in_x80_to_xBF(b){ /*<>*/ return 2 !== (b >>> 6 | 0) ? 1 : 0; @@ -5862,9 +5874,9 @@ /*<>*/ } function not_in_x90_to_xBF(b){ /*<>*/ var - _j_ = b < 144 ? 1 : 0, - _k_ = _j_ || (191 < b ? 1 : 0); - return _k_; + _k_ = b < 144 ? 1 : 0, + _l_ = _k_ || (191 < b ? 1 : 0); + return _l_; /*<>*/ } function not_in_x80_to_x8F(b){ /*<>*/ return 8 !== (b >>> 4 | 0) ? 1 : 0; @@ -6061,9 +6073,9 @@ (dec_invalid, 1); /*<>*/ } function set_utf_8_uchar(b, i, u){ - /*<>*/ function set(_i_, _h_, _g_){ - /*<>*/ caml_bytes_unsafe_set(_i_, _h_, _g_); - return 0; + /*<>*/ function set(_j_, _i_, _h_){ + /*<>*/ caml_bytes_unsafe_set(_j_, _i_, _h_); + return; } /*<>*/ var /*<>*/ max = @@ -7293,6 +7305,7 @@ : runtime.caml_call_gen(f, [a0, a1, a2]); } /*<>*/ var + _b_ = undefined, global_data = runtime.caml_get_global_data(), Stdlib_Seq = global_data.Stdlib__Seq, Assert_failure = global_data.Assert_failure, @@ -7320,16 +7333,16 @@ /*<>*/ res = /*<>*/ caml_make_vect (l, /*<>*/ caml_call1(f, 0)), - /*<>*/ _ay_ = l - 1 | 0, - /*<>*/ _ax_ = 1; - if(_ay_ >= 1){ - var i = _ax_; + /*<>*/ _az_ = l - 1 | 0, + /*<>*/ _ay_ = 1; + if(_az_ >= 1){ + var i = _ay_; for(;;){ /*<>*/ res[1 + i] = /*<>*/ caml_call1(f, i); - /*<>*/ /*<>*/ var _az_ = i + 1 | 0; - if(_ay_ === i) break; - var i = _az_; + /*<>*/ /*<>*/ var _aA_ = i + 1 | 0; + if(_az_ === i) break; + var i = _aA_; } } /*<>*/ return res; @@ -7338,15 +7351,15 @@ /*<>*/ var /*<>*/ res = /*<>*/ caml_make_vect(sx, [0]), - /*<>*/ _av_ = sx - 1 | 0, - /*<>*/ _au_ = 0; - if(_av_ >= 0){ - var x = _au_; + /*<>*/ _aw_ = sx - 1 | 0, + /*<>*/ _av_ = 0; + if(_aw_ >= 0){ + var x = _av_; for(;;){ res[1 + x] = /*<>*/ caml_make_vect(sy, init); - /*<>*/ /*<>*/ var _aw_ = x + 1 | 0; - if(_av_ === x) break; - var x = _aw_; + /*<>*/ /*<>*/ var _ax_ = x + 1 | 0; + if(_aw_ === x) break; + var x = _ax_; } } /*<>*/ return res; @@ -7397,15 +7410,15 @@ /*<>*/ } function iter(f, a){ /*<>*/ var - _as_ = a.length - 1 - 1 | 0, - /*<>*/ _ar_ = 0; - if(_as_ >= 0){ - var i = _ar_; + _at_ = a.length - 1 - 1 | 0, + /*<>*/ _as_ = 0; + if(_at_ >= 0){ + var i = _as_; for(;;){ /*<>*/ /*<>*/ caml_call1(f, a[1 + i]); - /*<>*/ /*<>*/ var _at_ = i + 1 | 0; - if(_as_ === i) break; - var i = _at_; + /*<>*/ /*<>*/ var _au_ = i + 1 | 0; + if(_at_ === i) break; + var i = _au_; } } return 0; @@ -7415,16 +7428,16 @@ /*<>*/ return /*<>*/ caml_call1 (Stdlib[1], cst_Array_iter2_arrays_must_ha); /*<>*/ var - _ap_ = a.length - 1 - 1 | 0, - /*<>*/ _ao_ = 0; - if(_ap_ >= 0){ - var i = _ao_; + _aq_ = a.length - 1 - 1 | 0, + /*<>*/ _ap_ = 0; + if(_aq_ >= 0){ + var i = _ap_; for(;;){ /*<>*/ /*<>*/ caml_call2 (f, a[1 + i], b[1 + i]); - /*<>*/ /*<>*/ var _aq_ = i + 1 | 0; - if(_ap_ === i) break; - var i = _aq_; + /*<>*/ /*<>*/ var _ar_ = i + 1 | 0; + if(_aq_ === i) break; + var i = _ar_; } } return 0; @@ -7436,48 +7449,48 @@ /*<>*/ r = /*<>*/ caml_make_vect (l, /*<>*/ caml_call1(f, a[1])), - /*<>*/ _am_ = l - 1 | 0, - /*<>*/ _al_ = 1; - if(_am_ >= 1){ - var i = _al_; + /*<>*/ _an_ = l - 1 | 0, + /*<>*/ _am_ = 1; + if(_an_ >= 1){ + var i = _am_; for(;;){ /*<>*/ r[1 + i] = /*<>*/ caml_call1(f, a[1 + i]); - /*<>*/ /*<>*/ var _an_ = i + 1 | 0; - if(_am_ === i) break; - var i = _an_; + /*<>*/ /*<>*/ var _ao_ = i + 1 | 0; + if(_an_ === i) break; + var i = _ao_; } } /*<>*/ return r; /*<>*/ } function map_inplace(f, a){ /*<>*/ var - _aj_ = a.length - 1 - 1 | 0, - /*<>*/ _ai_ = 0; - if(_aj_ >= 0){ - var i = _ai_; + _ak_ = a.length - 1 - 1 | 0, + /*<>*/ _aj_ = 0; + if(_ak_ >= 0){ + var i = _aj_; for(;;){ /*<>*/ a[1 + i] = /*<>*/ caml_call1(f, a[1 + i]); - /*<>*/ /*<>*/ var _ak_ = i + 1 | 0; - if(_aj_ === i) break; - var i = _ak_; + /*<>*/ /*<>*/ var _al_ = i + 1 | 0; + if(_ak_ === i) break; + var i = _al_; } } return 0; /*<>*/ } function mapi_inplace(f, a){ /*<>*/ var - _ag_ = a.length - 1 - 1 | 0, - /*<>*/ _af_ = 0; - if(_ag_ >= 0){ - var i = _af_; + _ah_ = a.length - 1 - 1 | 0, + /*<>*/ _ag_ = 0; + if(_ah_ >= 0){ + var i = _ag_; for(;;){ /*<>*/ a[1 + i] = /*<>*/ caml_call2(f, i, a[1 + i]); - /*<>*/ /*<>*/ var _ah_ = i + 1 | 0; - if(_ag_ === i) break; - var i = _ah_; + /*<>*/ /*<>*/ var _ai_ = i + 1 | 0; + if(_ah_ === i) break; + var i = _ai_; } } return 0; @@ -7494,32 +7507,32 @@ /*<>*/ r = /*<>*/ caml_make_vect (la, /*<>*/ caml_call2(f, a[1], b[1])), - /*<>*/ _ad_ = la - 1 | 0, - /*<>*/ _ac_ = 1; - if(_ad_ >= 1){ - var i = _ac_; + /*<>*/ _ae_ = la - 1 | 0, + /*<>*/ _ad_ = 1; + if(_ae_ >= 1){ + var i = _ad_; for(;;){ /*<>*/ r[1 + i] = /*<>*/ caml_call2(f, a[1 + i], b[1 + i]); - /*<>*/ /*<>*/ var _ae_ = i + 1 | 0; - if(_ad_ === i) break; - var i = _ae_; + /*<>*/ /*<>*/ var _af_ = i + 1 | 0; + if(_ae_ === i) break; + var i = _af_; } } /*<>*/ return r; /*<>*/ } function iteri(f, a){ /*<>*/ var - _aa_ = a.length - 1 - 1 | 0, - /*<>*/ _$_ = 0; - if(_aa_ >= 0){ - var i = _$_; + _ab_ = a.length - 1 - 1 | 0, + /*<>*/ _aa_ = 0; + if(_ab_ >= 0){ + var i = _aa_; for(;;){ /*<>*/ /*<>*/ caml_call2 (f, i, a[1 + i]); - /*<>*/ /*<>*/ var _ab_ = i + 1 | 0; - if(_aa_ === i) break; - var i = _ab_; + /*<>*/ /*<>*/ var _ac_ = i + 1 | 0; + if(_ab_ === i) break; + var i = _ac_; } } return 0; @@ -7531,16 +7544,16 @@ /*<>*/ r = /*<>*/ caml_make_vect (l, /*<>*/ caml_call2(f, 0, a[1])), - /*<>*/ _Z_ = l - 1 | 0, - /*<>*/ _Y_ = 1; - if(_Z_ >= 1){ - var i = _Y_; + /*<>*/ ___ = l - 1 | 0, + /*<>*/ _Z_ = 1; + if(___ >= 1){ + var i = _Z_; for(;;){ /*<>*/ r[1 + i] = /*<>*/ caml_call2(f, i, a[1 + i]); - /*<>*/ /*<>*/ var ___ = i + 1 | 0; - if(_Z_ === i) break; - var i = ___; + /*<>*/ /*<>*/ var _$_ = i + 1 | 0; + if(___ === i) break; + var i = _$_; } } /*<>*/ return r; @@ -7589,15 +7602,15 @@ function fold_left(f, x, a){ /*<>*/ var /*<>*/ r = [0, x], - _W_ = a.length - 1 - 1 | 0, - /*<>*/ _V_ = 0; - if(_W_ >= 0){ - var i = _V_; + _X_ = a.length - 1 - 1 | 0, + /*<>*/ _W_ = 0; + if(_X_ >= 0){ + var i = _W_; for(;;){ r[1] = /*<>*/ caml_call2(f, r[1], a[1 + i]); - /*<>*/ /*<>*/ var _X_ = i + 1 | 0; - if(_W_ === i) break; - var i = _X_; + /*<>*/ /*<>*/ var _Y_ = i + 1 | 0; + if(_X_ === i) break; + var i = _Y_; } } return r[1]; @@ -7614,10 +7627,10 @@ /*<>*/ output_array = /*<>*/ caml_make_vect(len, elt), /*<>*/ acc$1 = [0, acc$0], - /*<>*/ _T_ = len - 1 | 0, - /*<>*/ _S_ = 1; - if(_T_ >= 1){ - var i = _S_; + /*<>*/ _U_ = len - 1 | 0, + /*<>*/ _T_ = 1; + if(_U_ >= 1){ + var i = _T_; for(;;){ /*<>*/ var /*<>*/ match$0 = @@ -7626,9 +7639,9 @@ acc$2 = match$0[1]; acc$1[1] = acc$2; /*<>*/ output_array[1 + i] = elt$0; - /*<>*/ /*<>*/ var _U_ = i + 1 | 0; - if(_T_ === i) break; - var i = _U_; + /*<>*/ /*<>*/ var _V_ = i + 1 | 0; + if(_U_ === i) break; + var i = _V_; } } /*<>*/ return [0, acc$1[1], output_array]; @@ -7636,14 +7649,14 @@ function fold_right(f, a, x){ /*<>*/ var /*<>*/ r = [0, x], - /*<>*/ _Q_ = a.length - 1 - 1 | 0; - if(_Q_ >= 0){ - var i = _Q_; + /*<>*/ _R_ = a.length - 1 - 1 | 0; + if(_R_ >= 0){ + var i = _R_; for(;;){ r[1] = /*<>*/ caml_call2(f, a[1 + i], r[1]); - /*<>*/ /*<>*/ var _R_ = i - 1 | 0; + /*<>*/ /*<>*/ var _S_ = i - 1 | 0; if(0 === i) break; - var i = _R_; + var i = _S_; } } return r[1]; @@ -7787,17 +7800,17 @@ /*<>*/ caml_make_vect(n, a0), /*<>*/ b = /*<>*/ caml_make_vect(n, b0), - /*<>*/ _O_ = n - 1 | 0, - /*<>*/ _N_ = 1; - if(_O_ >= 1){ - var i = _N_; + /*<>*/ _P_ = n - 1 | 0, + /*<>*/ _O_ = 1; + if(_P_ >= 1){ + var i = _O_; for(;;){ var match$0 = x[1 + i], bi = match$0[2], ai = match$0[1]; /*<>*/ a[1 + i] = ai; /*<>*/ b[1 + i] = bi; - /*<>*/ /*<>*/ var _P_ = i + 1 | 0; - if(_O_ === i) break; - var i = _P_; + /*<>*/ /*<>*/ var _Q_ = i + 1 | 0; + if(_P_ === i) break; + var i = _Q_; } } /*<>*/ return [0, a, b]; @@ -7813,15 +7826,15 @@ /*<>*/ var /*<>*/ x = /*<>*/ caml_make_vect(na, [0, a[1], b[1]]), - /*<>*/ _L_ = na - 1 | 0, - /*<>*/ _K_ = 1; - if(_L_ >= 1){ - var i = _K_; + /*<>*/ _M_ = na - 1 | 0, + /*<>*/ _L_ = 1; + if(_M_ >= 1){ + var i = _L_; for(;;){ x[1 + i] = [0, a[1 + i], b[1 + i]]; - /*<>*/ /*<>*/ var _M_ = i + 1 | 0; - if(_L_ === i) break; - var i = _M_; + /*<>*/ /*<>*/ var _N_ = i + 1 | 0; + if(_M_ === i) break; + var i = _N_; } } /*<>*/ return x; @@ -7835,42 +7848,42 @@ /*<>*/ x = [0, i31]; if((i31 + 2 | 0) < l){ /*<>*/ var - /*<>*/ _D_ = i31 + 1 | 0, - /*<>*/ _E_ = caml_check_bound(a, _D_)[1 + _D_]; + /*<>*/ _E_ = i31 + 1 | 0, + /*<>*/ _F_ = caml_check_bound(a, _E_)[1 + _E_]; if ( /*<>*/ caml_call2 - (cmp, caml_check_bound(a, i31)[1 + i31], _E_) + (cmp, caml_check_bound(a, i31)[1 + i31], _F_) < 0) x[1] = i31 + 1 | 0; /*<>*/ var - /*<>*/ _F_ = i31 + 2 | 0, - /*<>*/ _G_ = caml_check_bound(a, _F_)[1 + _F_], - _H_ = x[1]; + /*<>*/ _G_ = i31 + 2 | 0, + /*<>*/ _H_ = caml_check_bound(a, _G_)[1 + _G_], + _I_ = x[1]; if ( /*<>*/ caml_call2 - (cmp, caml_check_bound(a, _H_)[1 + _H_], _G_) + (cmp, caml_check_bound(a, _I_)[1 + _I_], _H_) < 0) x[1] = i31 + 2 | 0; return x[1]; } if((i31 + 1 | 0) < l){ /*<>*/ var - _I_ = i31 + 1 | 0, - /*<>*/ _J_ = caml_check_bound(a, _I_)[1 + _I_]; + _J_ = i31 + 1 | 0, + /*<>*/ _K_ = caml_check_bound(a, _J_)[1 + _J_]; /*<>*/ if (0 > /*<>*/ caml_call2 - (cmp, caml_check_bound(a, i31)[1 + i31], _J_)) + (cmp, caml_check_bound(a, i31)[1 + i31], _K_)) /*<>*/ return i31 + 1 | 0; } if(i31 < l) /*<>*/ return i31; /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace ([0, Bottom, i], 1); /*<>*/ } - var l = a.length - 1, _x_ = ((l + 1 | 0) / 3 | 0) - 1 | 0; - if(_x_ >= 0){ - var i$6 = _x_; + var l = a.length - 1, _y_ = ((l + 1 | 0) / 3 | 0) - 1 | 0; + if(_y_ >= 0){ + var i$6 = _y_; for(;;){ /*<>*/ /*<>*/ var e$1 = caml_check_bound(a, i$6)[1 + i$6]; @@ -7888,8 +7901,8 @@ break; } /*<>*/ /*<>*/ var - _u_ = caml_check_bound(a, j)[1 + j]; - /*<>*/ caml_check_bound(a, i)[1 + i] = _u_; + _v_ = caml_check_bound(a, j)[1 + j]; + /*<>*/ caml_check_bound(a, i)[1 + i] = _v_; var i = j; } } @@ -7899,14 +7912,14 @@ var i$0 = exn[2]; /*<>*/ caml_check_bound(a, i$0)[1 + i$0] = e$1; } - /*<>*/ /*<>*/ var _C_ = i$6 - 1 | 0; + /*<>*/ /*<>*/ var _D_ = i$6 - 1 | 0; if(0 === i$6) break; - var i$6 = _C_; + var i$6 = _D_; } } - /*<>*/ /*<>*/ var _y_ = l - 1 | 0; - if(_y_ >= 2){ - var i$4 = _y_; + /*<>*/ /*<>*/ var _z_ = l - 1 | 0; + if(_z_ >= 2){ + var i$4 = _z_; a: for(;;){ /*<>*/ /*<>*/ var @@ -7918,8 +7931,8 @@ /*<>*/ for(;;){ /*<>*/ var /*<>*/ j$0 = maxson(i$4, i$1), - /*<>*/ _v_ = caml_check_bound(a, j$0)[1 + j$0]; - /*<>*/ caml_check_bound(a, i$1)[1 + i$1] = _v_; + /*<>*/ _w_ = caml_check_bound(a, j$0)[1 + j$0]; + /*<>*/ caml_check_bound(a, i$1)[1 + i$1] = _w_; var i$1 = j$0; } } @@ -7940,30 +7953,30 @@ /*<>*/ caml_check_bound(a, i$3)[1 + i$3] = e$0; else{ /*<>*/ /*<>*/ var - _w_ = caml_check_bound(a, father)[1 + father]; - /*<>*/ caml_check_bound(a, i$3)[1 + i$3] = _w_; + _x_ = caml_check_bound(a, father)[1 + father]; + /*<>*/ caml_check_bound(a, i$3)[1 + i$3] = _x_; if(0 < father){var i$3 = father; continue;} /*<>*/ caml_check_bound(a, 0)[1] = e$0; } - /*<>*/ /*<>*/ var _B_ = i$4 - 1 | 0; + /*<>*/ /*<>*/ var _C_ = i$4 - 1 | 0; if(2 === i$4) break a; - var i$4 = _B_; + var i$4 = _C_; break; } } } } - var _z_ = 1 < l ? 1 : 0; - if(_z_){ + var _A_ = 1 < l ? 1 : 0; + if(_A_){ /*<>*/ /*<>*/ var e = caml_check_bound(a, 1)[2]; /*<>*/ a[2] = caml_check_bound(a, 0)[1]; /*<>*/ a[1] = e; - var _A_ = 0; + var _B_ = 0; } else - var _A_ = _z_; - /*<>*/ return _A_; + var _B_ = _A_; + /*<>*/ return _B_; /*<>*/ } function stable_sort(cmp, a){ function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){ @@ -8007,38 +8020,38 @@ /*<>*/ } function isortto(srcofs, dst, dstofs, len){ /*<>*/ var - _m_ = len - 1 | 0, - /*<>*/ _l_ = 0; - if(_m_ >= 0){ - var i = _l_; + _n_ = len - 1 | 0, + /*<>*/ _m_ = 0; + if(_n_ >= 0){ + var i = _m_; a: for(;;){ /*<>*/ var - _n_ = srcofs + i | 0, - /*<>*/ e = caml_check_bound(a, _n_)[1 + _n_], + _o_ = srcofs + i | 0, + /*<>*/ e = caml_check_bound(a, _o_)[1 + _o_], /*<>*/ j = [0, (dstofs + i | 0) - 1 | 0]; for(;;){ if(dstofs <= j[1]){ - var _o_ = j[1]; + var _p_ = j[1]; /*<>*/ if (0 < /*<>*/ caml_call2 - (cmp, caml_check_bound(dst, _o_)[1 + _o_], e)){ + (cmp, caml_check_bound(dst, _p_)[1 + _p_], e)){ /*<>*/ var - _p_ = j[1], - /*<>*/ _q_ = caml_check_bound(dst, _p_)[1 + _p_], - _r_ = j[1] + 1 | 0; - /*<>*/ caml_check_bound(dst, _r_)[1 + _r_] = _q_; + _q_ = j[1], + /*<>*/ _r_ = caml_check_bound(dst, _q_)[1 + _q_], + _s_ = j[1] + 1 | 0; + /*<>*/ caml_check_bound(dst, _s_)[1 + _s_] = _r_; j[1] += -1; continue; } } - var _s_ = j[1] + 1 | 0; - /*<>*/ caml_check_bound(dst, _s_)[1 + _s_] = e; - /*<>*/ /*<>*/ var _t_ = i + 1 | 0; - if(_m_ === i) break a; - var i = _t_; + var _t_ = j[1] + 1 | 0; + /*<>*/ caml_check_bound(dst, _t_)[1 + _t_] = e; + /*<>*/ /*<>*/ var _u_ = i + 1 | 0; + if(_n_ === i) break a; + var i = _u_; break; } } @@ -8046,13 +8059,16 @@ return 0; /*<>*/ } function sortto(srcofs, dst, dstofs, len){ - /*<>*/ if(len <= 5) - /*<>*/ return isortto(srcofs, dst, dstofs, len); + /*<>*/ if(len <= 5){ + /*<>*/ isortto(srcofs, dst, dstofs, len); + /*<>*/ return; + } var l1 = len / 2 | 0, l2 = len - l1 | 0; /*<>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2); /*<>*/ sortto(srcofs, a, srcofs + l2 | 0, l1); - /*<>*/ return merge - (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs); + /*<>*/ merge + (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs); + /*<>*/ return; /*<>*/ } var l = a.length - 1; if(l <= 5) /*<>*/ return isortto(0, a, 0, l); @@ -8071,14 +8087,14 @@ /*<>*/ return 0; /*<>*/ var /*<>*/ x = a[1 + i], - /*<>*/ _j_ = i + 1 | 0; + /*<>*/ _k_ = i + 1 | 0; /*<>*/ return [0, x, - function(_k_){ /*<>*/ return aux(_j_, _k_);}]; + function(_l_){ /*<>*/ return aux(_k_, _l_);}]; /*<>*/ } - /*<>*/ /*<>*/ var _h_ = 0; - /*<>*/ return function(_i_){ - /*<>*/ return aux(_h_, _i_);}; + /*<>*/ /*<>*/ var _i_ = 0; + /*<>*/ return function(_j_){ + /*<>*/ return aux(_i_, _j_);}; /*<>*/ } function to_seqi(a){ function aux(i, param){ @@ -8086,22 +8102,22 @@ /*<>*/ return 0; /*<>*/ var /*<>*/ x = a[1 + i], - /*<>*/ _f_ = i + 1 | 0; + /*<>*/ _g_ = i + 1 | 0; /*<>*/ return [0, [0, i, x], - function(_g_){ /*<>*/ return aux(_f_, _g_);}]; + function(_h_){ /*<>*/ return aux(_g_, _h_);}]; /*<>*/ } - /*<>*/ /*<>*/ var _d_ = 0; - /*<>*/ return function(_e_){ - /*<>*/ return aux(_d_, _e_);}; + /*<>*/ /*<>*/ var _e_ = 0; + /*<>*/ return function(_f_){ + /*<>*/ return aux(_e_, _f_);}; /*<>*/ } function of_seq(i$2){ - /*<>*/ var _b_ = 0; - function _c_(acc, x){ + /*<>*/ var _c_ = 0; + function _d_(acc, x){ /*<>*/ return [0, x, acc]; /*<>*/ } /*<>*/ /*<>*/ var - l = /*<>*/ caml_call3(Stdlib_Seq[5], _c_, _b_, i$2); + l = /*<>*/ caml_call3(Stdlib_Seq[5], _d_, _c_, i$2); if(! l) /*<>*/ return [0]; /*<>*/ var tl = l[2], @@ -8205,6 +8221,7 @@ : runtime.caml_call_gen(f, [a0, a1, a2]); } /*<>*/ var + _j_ = undefined, global_data = runtime.caml_get_global_data(), Stdlib_Seq = global_data.Stdlib__Seq, Stdlib_List = global_data.Stdlib__List, @@ -8250,8 +8267,8 @@ pi = 3.141592653589793; function is_integer(x){ /*<>*/ var - _aw_ = x == /*<>*/ runtime.caml_trunc_float(x) ? 1 : 0; - return _aw_ ? is_finite(x) : _aw_; + _ax_ = x == /*<>*/ runtime.caml_trunc_float(x) ? 1 : 0; + return _ax_ ? is_finite(x) : _ax_; /*<>*/ } function succ(x){ /*<>*/ return /*<>*/ caml_nextafter_float @@ -8352,32 +8369,34 @@ (10, 100, 0, x); /*<>*/ } function unsafe_fill(a, ofs, len, v){ - /*<>*/ var _au_ = (ofs + len | 0) - 1 | 0; - if(_au_ >= ofs){ + /*<>*/ var _av_ = (ofs + len | 0) - 1 | 0; + if(_av_ >= ofs){ var i = ofs; for(;;){ /*<>*/ a[1 + i] = v; - /*<>*/ /*<>*/ var _av_ = i + 1 | 0; - if(_au_ === i) break; - var i = _av_; + /*<>*/ /*<>*/ var _aw_ = i + 1 | 0; + if(_av_ === i) break; + var i = _aw_; } } return 0; /*<>*/ } function check(a, ofs, len, msg){ - /*<>*/ var _aq_ = ofs < 0 ? 1 : 0; - if(_aq_) - var _ar_ = _aq_; + /*<>*/ var _ar_ = ofs < 0 ? 1 : 0; + if(_ar_) + var _as_ = _ar_; else{ - var _as_ = len < 0 ? 1 : 0; - if(_as_) - var _ar_ = _as_; + var _at_ = len < 0 ? 1 : 0; + if(_at_) + var _as_ = _at_; else var - _at_ = (ofs + len | 0) < 0 ? 1 : 0, - _ar_ = _at_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0); + _au_ = (ofs + len | 0) < 0 ? 1 : 0, + _as_ = _au_ || (a.length - 1 < (ofs + len | 0) ? 1 : 0); } - return _ar_ ? /*<>*/ caml_call1(Stdlib[1], msg) : _ar_; + if(! _as_) return _as_; + /*<>*/ /*<>*/ caml_call1(Stdlib[1], msg); + /*<>*/ return; /*<>*/ } function make(n, v){ /*<>*/ /*<>*/ var @@ -8392,16 +8411,16 @@ /*<>*/ var /*<>*/ res = /*<>*/ caml_floatarray_create(l), - /*<>*/ _ao_ = l - 1 | 0, - /*<>*/ _an_ = 0; - if(_ao_ >= 0){ - var i = _an_; + /*<>*/ _ap_ = l - 1 | 0, + /*<>*/ _ao_ = 0; + if(_ap_ >= 0){ + var i = _ao_; for(;;){ /*<>*/ res[1 + i] = /*<>*/ caml_call1(f, i); - /*<>*/ /*<>*/ var _ap_ = i + 1 | 0; - if(_ao_ === i) break; - var i = _ap_; + /*<>*/ /*<>*/ var _aq_ = i + 1 | 0; + if(_ap_ === i) break; + var i = _aq_; } } /*<>*/ return res; @@ -8483,11 +8502,11 @@ (src, sofs, dst, dofs, len); /*<>*/ } function to_list(a){ - /*<>*/ function _al_(_am_){ - /*<>*/ return a[1 + _am_]; + /*<>*/ function _am_(_an_){ + /*<>*/ return a[1 + _an_]; } /*<>*/ return /*<>*/ caml_call2 - (Stdlib_List[11], a.length - 1, _al_); + (Stdlib_List[11], a.length - 1, _am_); /*<>*/ } function of_list(l){ /*<>*/ var @@ -8508,16 +8527,16 @@ /*<>*/ } function iter(f, a){ /*<>*/ var - _aj_ = a.length - 1 - 1 | 0, - /*<>*/ _ai_ = 0; - if(_aj_ >= 0){ - var i = _ai_; + _ak_ = a.length - 1 - 1 | 0, + /*<>*/ _aj_ = 0; + if(_ak_ >= 0){ + var i = _aj_; for(;;){ /*<>*/ /*<>*/ caml_call1 (f, a[1 + i]); - /*<>*/ /*<>*/ var _ak_ = i + 1 | 0; - if(_aj_ === i) break; - var i = _ak_; + /*<>*/ /*<>*/ var _al_ = i + 1 | 0; + if(_ak_ === i) break; + var i = _al_; } } return 0; @@ -8527,16 +8546,16 @@ /*<>*/ return /*<>*/ caml_call1 (Stdlib[1], cst_Float_Array_iter2_arrays_m); /*<>*/ var - _ag_ = a.length - 1 - 1 | 0, - /*<>*/ _af_ = 0; - if(_ag_ >= 0){ - var i = _af_; + _ah_ = a.length - 1 - 1 | 0, + /*<>*/ _ag_ = 0; + if(_ah_ >= 0){ + var i = _ag_; for(;;){ /*<>*/ /*<>*/ caml_call2 (f, a[1 + i], b[1 + i]); - /*<>*/ /*<>*/ var _ah_ = i + 1 | 0; - if(_ag_ === i) break; - var i = _ah_; + /*<>*/ /*<>*/ var _ai_ = i + 1 | 0; + if(_ah_ === i) break; + var i = _ai_; } } return 0; @@ -8546,32 +8565,32 @@ l = a.length - 1, /*<>*/ r = /*<>*/ caml_floatarray_create(l), - /*<>*/ _ad_ = l - 1 | 0, - /*<>*/ _ac_ = 0; - if(_ad_ >= 0){ - var i = _ac_; + /*<>*/ _ae_ = l - 1 | 0, + /*<>*/ _ad_ = 0; + if(_ae_ >= 0){ + var i = _ad_; for(;;){ /*<>*/ r[1 + i] = /*<>*/ caml_call1(f, a[1 + i]); - /*<>*/ /*<>*/ var _ae_ = i + 1 | 0; - if(_ad_ === i) break; - var i = _ae_; + /*<>*/ /*<>*/ var _af_ = i + 1 | 0; + if(_ae_ === i) break; + var i = _af_; } } /*<>*/ return r; /*<>*/ } function map_inplace(f, a){ /*<>*/ var - _aa_ = a.length - 1 - 1 | 0, - /*<>*/ _$_ = 0; - if(_aa_ >= 0){ - var i = _$_; + _ab_ = a.length - 1 - 1 | 0, + /*<>*/ _aa_ = 0; + if(_ab_ >= 0){ + var i = _aa_; for(;;){ /*<>*/ a[1 + i] = /*<>*/ caml_call1(f, a[1 + i]); - /*<>*/ /*<>*/ var _ab_ = i + 1 | 0; - if(_aa_ === i) break; - var i = _ab_; + /*<>*/ /*<>*/ var _ac_ = i + 1 | 0; + if(_ab_ === i) break; + var i = _ac_; } } return 0; @@ -8586,32 +8605,32 @@ /*<>*/ var /*<>*/ r = /*<>*/ caml_floatarray_create(la), - /*<>*/ _Z_ = la - 1 | 0, - /*<>*/ _Y_ = 0; - if(_Z_ >= 0){ - var i = _Y_; + /*<>*/ ___ = la - 1 | 0, + /*<>*/ _Z_ = 0; + if(___ >= 0){ + var i = _Z_; for(;;){ /*<>*/ r[1 + i] = /*<>*/ caml_call2(f, a[1 + i], b[1 + i]); - /*<>*/ /*<>*/ var ___ = i + 1 | 0; - if(_Z_ === i) break; - var i = ___; + /*<>*/ /*<>*/ var _$_ = i + 1 | 0; + if(___ === i) break; + var i = _$_; } } /*<>*/ return r; /*<>*/ } function iteri(f, a){ /*<>*/ var - _W_ = a.length - 1 - 1 | 0, - /*<>*/ _V_ = 0; - if(_W_ >= 0){ - var i = _V_; + _X_ = a.length - 1 - 1 | 0, + /*<>*/ _W_ = 0; + if(_X_ >= 0){ + var i = _W_; for(;;){ /*<>*/ /*<>*/ caml_call2 (f, i, a[1 + i]); - /*<>*/ /*<>*/ var _X_ = i + 1 | 0; - if(_W_ === i) break; - var i = _X_; + /*<>*/ /*<>*/ var _Y_ = i + 1 | 0; + if(_X_ === i) break; + var i = _Y_; } } return 0; @@ -8621,32 +8640,32 @@ l = a.length - 1, /*<>*/ r = /*<>*/ caml_floatarray_create(l), - /*<>*/ _T_ = l - 1 | 0, - /*<>*/ _S_ = 0; - if(_T_ >= 0){ - var i = _S_; + /*<>*/ _U_ = l - 1 | 0, + /*<>*/ _T_ = 0; + if(_U_ >= 0){ + var i = _T_; for(;;){ /*<>*/ r[1 + i] = /*<>*/ caml_call2(f, i, a[1 + i]); - /*<>*/ /*<>*/ var _U_ = i + 1 | 0; - if(_T_ === i) break; - var i = _U_; + /*<>*/ /*<>*/ var _V_ = i + 1 | 0; + if(_U_ === i) break; + var i = _V_; } } /*<>*/ return r; /*<>*/ } function mapi_inplace(f, a){ /*<>*/ var - _Q_ = a.length - 1 - 1 | 0, - /*<>*/ _P_ = 0; - if(_Q_ >= 0){ - var i = _P_; + _R_ = a.length - 1 - 1 | 0, + /*<>*/ _Q_ = 0; + if(_R_ >= 0){ + var i = _Q_; for(;;){ /*<>*/ a[1 + i] = /*<>*/ caml_call2(f, i, a[1 + i]); - /*<>*/ /*<>*/ var _R_ = i + 1 | 0; - if(_Q_ === i) break; - var i = _R_; + /*<>*/ /*<>*/ var _S_ = i + 1 | 0; + if(_R_ === i) break; + var i = _S_; } } return 0; @@ -8654,15 +8673,15 @@ function fold_left(f, x, a){ /*<>*/ var /*<>*/ r = [0, x], - _N_ = a.length - 1 - 1 | 0, - /*<>*/ _M_ = 0; - if(_N_ >= 0){ - var i = _M_; + _O_ = a.length - 1 - 1 | 0, + /*<>*/ _N_ = 0; + if(_O_ >= 0){ + var i = _N_; for(;;){ r[1] = /*<>*/ caml_call2(f, r[1], a[1 + i]); - /*<>*/ /*<>*/ var _O_ = i + 1 | 0; - if(_N_ === i) break; - var i = _O_; + /*<>*/ /*<>*/ var _P_ = i + 1 | 0; + if(_O_ === i) break; + var i = _P_; } } return r[1]; @@ -8670,14 +8689,14 @@ function fold_right(f, a, x){ /*<>*/ var /*<>*/ r = [0, x], - /*<>*/ _K_ = a.length - 1 - 1 | 0; - if(_K_ >= 0){ - var i = _K_; + /*<>*/ _L_ = a.length - 1 - 1 | 0; + if(_L_ >= 0){ + var i = _L_; for(;;){ r[1] = /*<>*/ caml_call2(f, a[1 + i], r[1]); - /*<>*/ /*<>*/ var _L_ = i - 1 | 0; + /*<>*/ /*<>*/ var _M_ = i - 1 | 0; if(0 === i) break; - var i = _L_; + var i = _M_; } } return r[1]; @@ -8813,9 +8832,9 @@ /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace ([0, Bottom, i], 1); /*<>*/ } - var l = a.length - 1, _E_ = ((l + 1 | 0) / 3 | 0) - 1 | 0; - if(_E_ >= 0){ - var i$6 = _E_; + var l = a.length - 1, _F_ = ((l + 1 | 0) / 3 | 0) - 1 | 0; + if(_F_ >= 0){ + var i$6 = _F_; for(;;){ /*<>*/ /*<>*/ var e$1 = /*<>*/ caml_array_get(a, i$6); @@ -8845,14 +8864,14 @@ /*<>*/ /*<>*/ caml_array_set (a, i$0, e$1); } - /*<>*/ /*<>*/ var _J_ = i$6 - 1 | 0; + /*<>*/ /*<>*/ var _K_ = i$6 - 1 | 0; if(0 === i$6) break; - var i$6 = _J_; + var i$6 = _K_; } } - /*<>*/ /*<>*/ var _F_ = l - 1 | 0; - if(_F_ >= 2){ - var i$4 = _F_; + /*<>*/ /*<>*/ var _G_ = l - 1 | 0; + if(_G_ >= 2){ + var i$4 = _G_; a: for(;;){ /*<>*/ /*<>*/ var @@ -8893,25 +8912,25 @@ /*<>*/ /*<>*/ caml_array_set (a, 0, e$0); } - /*<>*/ /*<>*/ var _I_ = i$4 - 1 | 0; + /*<>*/ /*<>*/ var _J_ = i$4 - 1 | 0; if(2 === i$4) break a; - var i$4 = _I_; + var i$4 = _J_; break; } } } } - var _G_ = 1 < l ? 1 : 0; - if(_G_){ + var _H_ = 1 < l ? 1 : 0; + if(_H_){ /*<>*/ /*<>*/ var e = /*<>*/ caml_array_get(a, 1); /*<>*/ /*<>*/ caml_array_set (a, 1, /*<>*/ caml_array_get(a, 0)); - var _H_ = /*<>*/ caml_array_set(a, 0, e); + var _I_ = /*<>*/ caml_array_set(a, 0, e); } else - var _H_ = _G_; - /*<>*/ return _H_; + var _I_ = _H_; + /*<>*/ return _I_; /*<>*/ } function stable_sort(cmp, a){ function merge(src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs){ @@ -8961,10 +8980,10 @@ /*<>*/ } function isortto(srcofs, dst, dstofs, len){ /*<>*/ var - _C_ = len - 1 | 0, - /*<>*/ _B_ = 0; - if(_C_ >= 0){ - var i = _B_; + _D_ = len - 1 | 0, + /*<>*/ _C_ = 0; + if(_D_ >= 0){ + var i = _C_; a: for(;;){ /*<>*/ var @@ -8988,9 +9007,9 @@ } /*<>*/ /*<>*/ caml_array_set (dst, j[1] + 1 | 0, e); - /*<>*/ /*<>*/ var _D_ = i + 1 | 0; - if(_C_ === i) break a; - var i = _D_; + /*<>*/ /*<>*/ var _E_ = i + 1 | 0; + if(_D_ === i) break a; + var i = _E_; break; } } @@ -8998,13 +9017,16 @@ return 0; /*<>*/ } function sortto(srcofs, dst, dstofs, len){ - /*<>*/ if(len <= 5) - /*<>*/ return isortto(srcofs, dst, dstofs, len); + /*<>*/ if(len <= 5){ + /*<>*/ isortto(srcofs, dst, dstofs, len); + /*<>*/ return; + } var l1 = len / 2 | 0, l2 = len - l1 | 0; /*<>*/ sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2); /*<>*/ sortto(srcofs, a, srcofs + l2 | 0, l1); - /*<>*/ return merge - (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs); + /*<>*/ merge + (srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs); + /*<>*/ return; /*<>*/ } var l = a.length - 1; if(l <= 5) /*<>*/ return isortto(0, a, 0, l); @@ -9023,14 +9045,14 @@ /*<>*/ return 0; /*<>*/ var /*<>*/ x = a[1 + i], - /*<>*/ _z_ = i + 1 | 0; + /*<>*/ _A_ = i + 1 | 0; /*<>*/ return [0, x, - function(_A_){ /*<>*/ return aux(_z_, _A_);}]; + function(_B_){ /*<>*/ return aux(_A_, _B_);}]; /*<>*/ } - /*<>*/ /*<>*/ var _x_ = 0; - /*<>*/ return function(_y_){ - /*<>*/ return aux(_x_, _y_);}; + /*<>*/ /*<>*/ var _y_ = 0; + /*<>*/ return function(_z_){ + /*<>*/ return aux(_y_, _z_);}; /*<>*/ } function to_seqi(a){ function aux(i, param){ @@ -9038,23 +9060,23 @@ /*<>*/ return 0; /*<>*/ var /*<>*/ x = a[1 + i], - /*<>*/ _v_ = i + 1 | 0; + /*<>*/ _w_ = i + 1 | 0; /*<>*/ return [0, [0, i, x], - function(_w_){ /*<>*/ return aux(_v_, _w_);}]; + function(_x_){ /*<>*/ return aux(_w_, _x_);}]; /*<>*/ } - /*<>*/ /*<>*/ var _t_ = 0; - /*<>*/ return function(_u_){ - /*<>*/ return aux(_t_, _u_);}; + /*<>*/ /*<>*/ var _u_ = 0; + /*<>*/ return function(_v_){ + /*<>*/ return aux(_u_, _v_);}; /*<>*/ } function of_seq(i$2){ - /*<>*/ var _r_ = 0; - function _s_(acc, x){ + /*<>*/ var _s_ = 0; + function _t_(acc, x){ /*<>*/ return [0, x, acc]; /*<>*/ } /*<>*/ var /*<>*/ l = - /*<>*/ caml_call3(Stdlib_Seq[5], _s_, _r_, i$2), + /*<>*/ caml_call3(Stdlib_Seq[5], _t_, _s_, i$2), /*<>*/ len = /*<>*/ caml_call1(Stdlib_List[1], l), /*<>*/ a = @@ -9079,16 +9101,16 @@ /*<>*/ r = /*<>*/ runtime.caml_make_vect (l, /*<>*/ caml_call1(f, a[1])), - /*<>*/ _p_ = l - 1 | 0, - /*<>*/ _o_ = 1; - if(_p_ >= 1){ - var i = _o_; + /*<>*/ _q_ = l - 1 | 0, + /*<>*/ _p_ = 1; + if(_q_ >= 1){ + var i = _p_; for(;;){ /*<>*/ r[1 + i] = /*<>*/ caml_call1(f, a[1 + i]); - /*<>*/ /*<>*/ var _q_ = i + 1 | 0; - if(_p_ === i) break; - var i = _q_; + /*<>*/ /*<>*/ var _r_ = i + 1 | 0; + if(_q_ === i) break; + var i = _r_; } } /*<>*/ return r; @@ -9098,16 +9120,16 @@ l = a.length - 1, /*<>*/ r = /*<>*/ caml_floatarray_create(l), - /*<>*/ _m_ = l - 1 | 0, - /*<>*/ _l_ = 0; - if(_m_ >= 0){ - var i = _l_; + /*<>*/ _n_ = l - 1 | 0, + /*<>*/ _m_ = 0; + if(_n_ >= 0){ + var i = _m_; for(;;){ /*<>*/ r[1 + i] = /*<>*/ caml_call1(f, a[1 + i]); - /*<>*/ /*<>*/ var _n_ = i + 1 | 0; - if(_m_ === i) break; - var i = _n_; + /*<>*/ /*<>*/ var _o_ = i + 1 | 0; + if(_n_ === i) break; + var i = _o_; } } /*<>*/ return r; @@ -9118,7 +9140,7 @@ _e_ = caml_array_get, _f_ = [0, - function(_k_){ /*<>*/ return _k_.length - 1;}, + function(_l_){ /*<>*/ return _l_.length - 1;}, _e_, _d_, make, @@ -9194,7 +9216,7 @@ seeded_hash, hash, [0, - function(_j_){ /*<>*/ return _j_.length - 1;}, + function(_k_){ /*<>*/ return _k_.length - 1;}, _i_, _h_, make, @@ -10058,6 +10080,7 @@ 0, 0, 0], + _a_ = undefined, cst_syntax_error = "syntax error"; function grow_stacks(param){ /*<>*/ var @@ -10084,7 +10107,7 @@ (Stdlib_Array[8], env[4], 0, new_end, 0, oldsize); env[4] = new_end; env[5] = newsize; - return 0; + return; /*<>*/ } function clear_parser(param){ /*<>*/ /*<>*/ caml_call4 @@ -10137,17 +10160,17 @@ case 4: try{ /*<>*/ var - _i_ = env[13], - /*<>*/ _j_ = + _j_ = env[13], + /*<>*/ _k_ = /*<>*/ caml_call1 - (caml_check_bound(tables[1], _i_)[1 + _i_], env), - /*<>*/ _k_ = 4, - value = _j_, - action = _k_; + (caml_check_bound(tables[1], _j_)[1 + _j_], env), + /*<>*/ _l_ = 4, + value = _k_, + action = _l_; } - catch(_m_){ - var _h_ = caml_wrap_exception(_m_); - if(_h_ !== Parse_error) throw caml_maybe_attach_backtrace(_h_, 0); + catch(_n_){ + var _i_ = caml_wrap_exception(_n_); + if(_i_ !== Parse_error) throw caml_maybe_attach_backtrace(_i_, 0); var value = 0, action = 5; } var cmd = action, arg = value; @@ -10183,9 +10206,9 @@ ? 1 : 0; /*<>*/ /*<>*/ var - _l_ = /*<>*/ runtime.caml_obj_tag(tok); - /*<>*/ return caml_check_bound(tables[3], _l_) - [1 + _l_] + _m_ = /*<>*/ runtime.caml_obj_tag(tok); + /*<>*/ return caml_check_bound(tables[3], _m_) + [1 + _m_] === curr_char ? 1 : 0; @@ -10195,21 +10218,21 @@ } /*<>*/ } function peek_val(env, n){ - /*<>*/ var _g_ = env[11] - n | 0; - /*<>*/ return caml_check_bound(env[2], _g_)[1 + _g_]; + /*<>*/ var _h_ = env[11] - n | 0; + /*<>*/ return caml_check_bound(env[2], _h_)[1 + _h_]; /*<>*/ } function symbol_start_pos(param){ /*<>*/ var i$1 = env[12], i = i$1; /*<>*/ for(;;){ if(0 >= i){ - var _f_ = env[11]; - /*<>*/ return caml_check_bound(env[4], _f_)[1 + _f_]; + var _g_ = env[11]; + /*<>*/ return caml_check_bound(env[4], _g_)[1 + _g_]; } /*<>*/ var - _d_ = (env[11] - i | 0) + 1 | 0, - /*<>*/ st = caml_check_bound(env[3], _d_)[1 + _d_], _e_ = (env[11] - i | 0) + 1 | 0, - /*<>*/ en = caml_check_bound(env[4], _e_)[1 + _e_]; + /*<>*/ st = caml_check_bound(env[3], _e_)[1 + _e_], + _f_ = (env[11] - i | 0) + 1 | 0, + /*<>*/ en = caml_check_bound(env[4], _f_)[1 + _f_]; /*<>*/ if ( /*<>*/ runtime.caml_notequal(st, en)) /*<>*/ return st; @@ -10219,16 +10242,16 @@ } /*<>*/ } function symbol_end_pos(param){ - /*<>*/ var _c_ = env[11]; - /*<>*/ return caml_check_bound(env[4], _c_)[1 + _c_]; + /*<>*/ var _d_ = env[11]; + /*<>*/ return caml_check_bound(env[4], _d_)[1 + _d_]; /*<>*/ } function rhs_start_pos(n){ - /*<>*/ var _b_ = env[11] - (env[12] - n | 0) | 0; - /*<>*/ return caml_check_bound(env[3], _b_)[1 + _b_]; + /*<>*/ var _c_ = env[11] - (env[12] - n | 0) | 0; + /*<>*/ return caml_check_bound(env[3], _c_)[1 + _c_]; /*<>*/ } function rhs_end_pos(n){ - /*<>*/ var _a_ = env[11] - (env[12] - n | 0) | 0; - /*<>*/ return caml_check_bound(env[4], _a_)[1 + _a_]; + /*<>*/ var _b_ = env[11] - (env[12] - n | 0) | 0; + /*<>*/ return caml_check_bound(env[4], _b_)[1 + _b_]; /*<>*/ } function symbol_start(param){ /*<>*/ return symbol_start_pos(0)[4]; @@ -12663,6 +12686,7 @@ Stdlib = global_data.Stdlib, Stdlib_String = global_data.Stdlib__String, Assert_failure = global_data.Assert_failure, + _b_ = undefined, cst_Buffer_truncate = "Buffer.truncate", _a_ = [0, "buffer.ml", 220, 9], cst_Buffer_add_channel = "Buffer.add_channel", @@ -12751,7 +12775,7 @@ /*<>*/ /*<>*/ caml_call5 (Stdlib_Bytes[11], b[1][1], 0, new_buffer, 0, b[2]); b[1] = [0, new_buffer, new_len[1]]; - return 0; + return; } new_len[1] = 2 * new_len[1] | 0; } @@ -12813,14 +12837,14 @@ } /*<>*/ } function add_substring(b, s, offset, len){ - /*<>*/ var _r_ = offset < 0 ? 1 : 0; - if(_r_) - var _s_ = _r_; + /*<>*/ var _s_ = offset < 0 ? 1 : 0; + if(_s_) + var _t_ = _s_; else var - _t_ = len < 0 ? 1 : 0, - _s_ = _t_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0); - if(_s_) + _u_ = len < 0 ? 1 : 0, + _t_ = _u_ || ((caml_ml_string_length(s) - len | 0) < offset ? 1 : 0); + if(_t_) /*<>*/ /*<>*/ caml_call1 (Stdlib[1], cst_Buffer_add_substring_add_s); /*<>*/ var @@ -12875,9 +12899,9 @@ /*<>*/ } function add_channel(b, ic, to_read$1){ /*<>*/ var - _p_ = to_read$1 < 0 ? 1 : 0, - _q_ = _p_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0); - if(_q_) + _q_ = to_read$1 < 0 ? 1 : 0, + _r_ = _q_ || (Stdlib_Sys[12] < to_read$1 ? 1 : 0); + if(_r_) /*<>*/ /*<>*/ caml_call1 (Stdlib[1], cst_Buffer_add_channel); if(b[1][2] < (b[2] + to_read$1 | 0)) @@ -12923,8 +12947,8 @@ i$4 = 0; /*<>*/ for(;;){ if(i$4 >= lim$1){ - var _o_ = 92 === previous ? 1 : 0; - return _o_ ? add_char(b, previous) : _o_; + var _p_ = 92 === previous ? 1 : 0; + return _p_ ? add_char(b, previous) : _p_; } /*<>*/ /*<>*/ var previous$0 = /*<>*/ caml_string_get(s, i$4); @@ -13064,14 +13088,14 @@ /*<>*/ var /*<>*/ x = /*<>*/ caml_bytes_get(b[1][1], i), - /*<>*/ _m_ = i + 1 | 0; + /*<>*/ _n_ = i + 1 | 0; /*<>*/ return [0, x, - function(_n_){ /*<>*/ return aux(_m_, _n_);}]; + function(_o_){ /*<>*/ return aux(_n_, _o_);}]; /*<>*/ } - /*<>*/ /*<>*/ var _k_ = 0; - /*<>*/ return function(_l_){ - /*<>*/ return aux(_k_, _l_);}; + /*<>*/ /*<>*/ var _l_ = 0; + /*<>*/ return function(_m_){ + /*<>*/ return aux(_l_, _m_);}; /*<>*/ } function to_seqi(b){ function aux(i, param){ @@ -13080,21 +13104,21 @@ /*<>*/ var /*<>*/ x = /*<>*/ caml_bytes_get(b[1][1], i), - /*<>*/ _i_ = i + 1 | 0; + /*<>*/ _j_ = i + 1 | 0; /*<>*/ return [0, [0, i, x], - function(_j_){ /*<>*/ return aux(_i_, _j_);}]; + function(_k_){ /*<>*/ return aux(_j_, _k_);}]; /*<>*/ } - /*<>*/ /*<>*/ var _g_ = 0; - /*<>*/ return function(_h_){ - /*<>*/ return aux(_g_, _h_);}; + /*<>*/ /*<>*/ var _h_ = 0; + /*<>*/ return function(_i_){ + /*<>*/ return aux(_h_, _i_);}; /*<>*/ } function add_seq(b, seq){ - /*<>*/ function _e_(_f_){ - /*<>*/ return add_char(b, _f_); + /*<>*/ function _f_(_g_){ + /*<>*/ return add_char(b, _g_); } /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Seq[4], _e_, seq); + (Stdlib_Seq[4], _f_, seq); /*<>*/ } function of_seq(i){ /*<>*/ /*<>*/ var b = create(32); @@ -13173,8 +13197,8 @@ return 0; /*<>*/ } function add_int16_le(b, x){ - /*<>*/ var _d_ = Stdlib_Sys[11] ? caml_bswap16(x) : x; - return add_int16_ne(b, _d_); + /*<>*/ var _e_ = Stdlib_Sys[11] ? caml_bswap16(x) : x; + return add_int16_ne(b, _e_); /*<>*/ } function add_int16_be(b, x){ /*<>*/ var x$0 = Stdlib_Sys[11] ? x : caml_bswap16(x); @@ -13182,8 +13206,8 @@ /*<>*/ } function add_int32_le(b, x){ /*<>*/ var - _c_ = Stdlib_Sys[11] ? /*<>*/ caml_int32_bswap(x) : x; - /*<>*/ return add_int32_ne(b, _c_); + _d_ = Stdlib_Sys[11] ? /*<>*/ caml_int32_bswap(x) : x; + /*<>*/ return add_int32_ne(b, _d_); /*<>*/ } function add_int32_be(b, x){ /*<>*/ var @@ -13192,8 +13216,8 @@ /*<>*/ } function add_int64_le(b, x){ /*<>*/ var - _b_ = Stdlib_Sys[11] ? /*<>*/ caml_int64_bswap(x) : x; - /*<>*/ return add_int64_ne(b, _b_); + _c_ = Stdlib_Sys[11] ? /*<>*/ caml_int64_bswap(x) : x; + /*<>*/ return add_int64_ne(b, _c_); /*<>*/ } function add_int64_be(b, x){ /*<>*/ var @@ -13460,6 +13484,7 @@ : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]); } var + _a_ = undefined, global_data = runtime.caml_get_global_data(), Stdlib_Mutex = global_data.Stdlib__Mutex, Stdlib_Condition = global_data.Stdlib__Condition, @@ -13478,8 +13503,8 @@ function create_dls(param){ /*<>*/ /*<>*/ var st = /*<>*/ caml_make_vect(8, unique_value); - /*<>*/ return /*<>*/ caml_domain_dls_set - (st); + /*<>*/ /*<>*/ caml_domain_dls_set(st); + /*<>*/ return; /*<>*/ } /*<>*/ create_dls(0); /*<>*/ var @@ -13568,7 +13593,7 @@ /*<>*/ first_spawn_function = [0, function(param){ - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }]; function before_first_spawn(f){ /*<>*/ if @@ -13589,7 +13614,7 @@ at_exit_key = new_key (0, - function(param, _e_){ + function(param, _f_){ /*<>*/ return 0; /*<>*/ }); function at_exit(f){ @@ -13624,8 +13649,8 @@ /*<>*/ }; } /*<>*/ /*<>*/ var - _a_ = /*<>*/ caml_call1(Stdlib_Atomic[2], parent_keys); - function _b_(param){ + _b_ = /*<>*/ caml_call1(Stdlib_Atomic[2], parent_keys); + function _c_(param){ /*<>*/ var split = param[2], k = param[1], idx = k[1]; /*<>*/ return [0, idx, @@ -13633,7 +13658,7 @@ /*<>*/ } /*<>*/ var /*<>*/ pk = - /*<>*/ caml_call2(Stdlib_List[20], _b_, _a_), + /*<>*/ caml_call2(Stdlib_List[20], _c_, _b_), /*<>*/ term_mutex = /*<>*/ caml_call1(Stdlib_Mutex[1], 0), /*<>*/ term_condition = @@ -13645,7 +13670,7 @@ /*<>*/ try{ /*<>*/ create_dls(0); var - _c_ = + _d_ = function(param){ /*<>*/ var v = param[2], @@ -13655,7 +13680,7 @@ /*<>*/ return 0; /*<>*/ }; /*<>*/ /*<>*/ caml_call2 - (Stdlib_List[18], _c_, pk); + (Stdlib_List[18], _d_, pk); /*<>*/ /*<>*/ var res = /*<>*/ caml_call1(f, 0); } @@ -13672,8 +13697,8 @@ catch(ex){ /*<>*/ var ex$0 = caml_wrap_exception(ex), - /*<>*/ _d_ = 0 === result[0] ? [1, ex$0] : result, - result$0 = _d_; + /*<>*/ _e_ = 0 === result[0] ? [1, ex$0] : result, + result$0 = _e_; } /*<>*/ /*<>*/ caml_call1 (Stdlib_Mutex[2], term_mutex); @@ -13804,6 +13829,7 @@ : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4]); } var + _$_ = undefined, global_data = runtime.caml_get_global_data(), cst$9 = "%{", cst$10 = "%}", @@ -14130,14 +14156,14 @@ /*<>*/ var str_ind = c >>> 3 | 0, mask = 1 << (c & 7), - /*<>*/ _dU_ = + /*<>*/ _dT_ = /*<>*/ runtime.caml_bytes_get (char_set, str_ind) | mask; /*<>*/ return /*<>*/ caml_bytes_set (char_set, str_ind, - /*<>*/ caml_call1(Stdlib[29], _dU_)); + /*<>*/ caml_call1(Stdlib[29], _dT_)); /*<>*/ } function freeze_char_set(char_set){ /*<>*/ return /*<>*/ caml_call1 @@ -14149,19 +14175,19 @@ i = 0; for(;;){ /*<>*/ /*<>*/ var - _dS_ = + _dR_ = /*<>*/ caml_string_get(char_set, i) ^ 255; /*<>*/ /*<>*/ caml_bytes_set (char_set$0, i, - /*<>*/ caml_call1(Stdlib[29], _dS_)); + /*<>*/ caml_call1(Stdlib[29], _dR_)); /*<>*/ /*<>*/ var - _dT_ = i + 1 | 0; + _dS_ = i + 1 | 0; if(31 === i) /*<>*/ return /*<>*/ caml_call1 (Stdlib_Bytes[44], char_set$0); - var i = _dT_; + var i = _dS_; } /*<>*/ } function is_in_char_set(char_set, c){ @@ -14221,11 +14247,11 @@ case 6: var prec_opt = ign[2], pad_opt$5 = ign[1]; if(prec_opt) - var ndec = prec_opt[1], _dR_ = [0, ndec]; + var ndec = prec_opt[1], _dQ_ = [0, ndec]; else - var _dR_ = 0; + var _dQ_ = 0; /*<>*/ return [0, - [8, _a_, pad_of_pad_opt(pad_opt$5), _dR_, fmt]]; + [8, _a_, pad_of_pad_opt(pad_opt$5), _dQ_, fmt]]; case 7: var pad_opt$6 = ign[1]; /*<>*/ return [0, @@ -14258,9 +14284,8 @@ function buffer_check_size(buf, overhead){ /*<>*/ var len = runtime.caml_ml_bytes_length(buf[2]), - min_len = buf[1] + overhead | 0, - _dP_ = len < min_len ? 1 : 0; - if(_dP_){ + min_len = buf[1] + overhead | 0; + if(len < min_len){ /*<>*/ var /*<>*/ new_len = /*<>*/ caml_call2 @@ -14270,18 +14295,15 @@ /*<>*/ /*<>*/ caml_call5 (Stdlib_Bytes[11], buf[2], 0, new_str, 0, len); buf[2] = new_str; - var _dQ_ = 0; } - else - var _dQ_ = _dP_; - return _dQ_; + return; /*<>*/ } function buffer_add_char(buf, c){ /*<>*/ buffer_check_size(buf, 1); /*<>*/ /*<>*/ caml_bytes_set (buf[2], buf[1], c); buf[1] = buf[1] + 1 | 0; - return 0; + return; /*<>*/ } function buffer_add_string(buf, s){ /*<>*/ var @@ -14290,7 +14312,7 @@ /*<>*/ /*<>*/ caml_call5 (Stdlib_String[6], s, 0, buf[2], buf[1], str_len); buf[1] = buf[1] + str_len | 0; - return 0; + return; /*<>*/ } function buffer_contents(buf){ /*<>*/ return caml_call3 @@ -14346,68 +14368,78 @@ function bprint_padty(buf, padty){ /*<>*/ switch(padty){ case 0: - /*<>*/ return buffer_add_char(buf, 45); + /*<>*/ buffer_add_char(buf, 45); + /*<>*/ return; case 1: - /*<>*/ return 0; + /*<>*/ return; default: - /*<>*/ return buffer_add_char(buf, 48); + /*<>*/ buffer_add_char(buf, 48); + /*<>*/ return; } /*<>*/ } function bprint_ignored_flag(buf, ign_flag){ - /*<>*/ return ign_flag - ? buffer_add_char(buf, 95) - : ign_flag; + /*<>*/ if(! ign_flag) + /*<>*/ return ign_flag; + /*<>*/ buffer_add_char(buf, 95); + /*<>*/ return; /*<>*/ } function bprint_pad_opt(buf, pad_opt){ /*<>*/ if(! pad_opt) - /*<>*/ return 0; + /*<>*/ return; var width = pad_opt[1]; - /*<>*/ return buffer_add_string - (buf, - /*<>*/ caml_call1 - (Stdlib_Int[12], width)); + /*<>*/ buffer_add_string + (buf, + /*<>*/ caml_call1(Stdlib_Int[12], width)); + /*<>*/ return; /*<>*/ } function bprint_padding(buf, pad){ /*<>*/ if(typeof pad === "number") - /*<>*/ return 0; + /*<>*/ return; if(0 === pad[0]){ var n = pad[2], padty = pad[1]; /*<>*/ bprint_padty(buf, padty); - /*<>*/ return buffer_add_string - (buf, - /*<>*/ caml_call1 - (Stdlib_Int[12], n)); + /*<>*/ buffer_add_string + (buf, + /*<>*/ caml_call1(Stdlib_Int[12], n)); + /*<>*/ return; } var padty$0 = pad[1]; /*<>*/ bprint_padty(buf, padty$0); - /*<>*/ return buffer_add_char(buf, 42); + /*<>*/ buffer_add_char(buf, 42); + /*<>*/ return; /*<>*/ } function bprint_precision(buf, prec){ - /*<>*/ if(typeof prec === "number") - return prec ? buffer_add_string(buf, cst) : 0; - var n = prec[1]; - /*<>*/ buffer_add_char(buf, 46); - /*<>*/ return buffer_add_string - (buf, - /*<>*/ caml_call1 - (Stdlib_Int[12], n)); + /*<>*/ if(typeof prec !== "number"){ + var n = prec[1]; + /*<>*/ buffer_add_char(buf, 46); + /*<>*/ buffer_add_string + (buf, + /*<>*/ caml_call1(Stdlib_Int[12], n)); + /*<>*/ return; + } + if(! prec) /*<>*/ return; + /*<>*/ buffer_add_string(buf, cst); + /*<>*/ return; /*<>*/ } function bprint_iconv_flag(buf, iconv){ /*<>*/ switch(iconv){ case 1: case 4: - /*<>*/ return buffer_add_char(buf, 43); + /*<>*/ buffer_add_char(buf, 43); + /*<>*/ return; case 2: case 5: - /*<>*/ return buffer_add_char(buf, 32); + /*<>*/ buffer_add_char(buf, 32); + /*<>*/ return; case 7: case 9: case 11: case 13: case 14: case 15: - /*<>*/ return buffer_add_char(buf, 35); - default: /*<>*/ return 0; + /*<>*/ buffer_add_char(buf, 35); + /*<>*/ return; + default: /*<>*/ return; } /*<>*/ } function bprint_altint_fmt(buf, ign_flag, iconv, pad, prec, c){ @@ -14417,8 +14449,9 @@ /*<>*/ bprint_padding(buf, pad); /*<>*/ bprint_precision(buf, prec); /*<>*/ buffer_add_char(buf, c); - /*<>*/ return buffer_add_char - (buf, char_of_iconv(iconv)); + /*<>*/ buffer_add_char + (buf, char_of_iconv(iconv)); + /*<>*/ return; /*<>*/ } function bprint_fconv_flag(buf, fconv){ /*<>*/ switch(fconv[1]){ @@ -14427,7 +14460,9 @@ /*<>*/ buffer_add_char(buf, 43); break; default: /*<>*/ buffer_add_char(buf, 32); } - return 8 <= fconv[2] ? buffer_add_char(buf, 35) : 0; + if(8 > fconv[2]) /*<>*/ return; + /*<>*/ buffer_add_char(buf, 35); + /*<>*/ return; /*<>*/ } function string_of_formatting_lit(formatting_lit){ /*<>*/ if @@ -14457,40 +14492,43 @@ default: /*<>*/ var c = formatting_lit[1], - /*<>*/ _dO_ = + /*<>*/ _dP_ = /*<>*/ caml_call2 (Stdlib_String[1], 1, c); /*<>*/ return /*<>*/ caml_call2 - (Stdlib[28], cst$7, _dO_); + (Stdlib[28], cst$7, _dP_); } /*<>*/ } function bprint_char_literal(buf, chr){ - /*<>*/ return 37 === chr - ? buffer_add_string(buf, cst$8) - : buffer_add_char(buf, chr); + /*<>*/ if(37 === chr){ + /*<>*/ buffer_add_string(buf, cst$8); + /*<>*/ return; + } + /*<>*/ buffer_add_char(buf, chr); + /*<>*/ return; /*<>*/ } function bprint_string_literal(buf, str){ /*<>*/ var - _dM_ = caml_ml_string_length(str) - 1 | 0, - /*<>*/ _dL_ = 0; - if(_dM_ >= 0){ - var i = _dL_; + _dN_ = caml_ml_string_length(str) - 1 | 0, + /*<>*/ _dM_ = 0; + if(_dN_ >= 0){ + var i = _dM_; for(;;){ /*<>*/ bprint_char_literal (buf, /*<>*/ caml_string_get(str, i)); /*<>*/ /*<>*/ var - _dN_ = i + 1 | 0; - if(_dM_ === i) break; - var i = _dN_; + _dO_ = i + 1 | 0; + if(_dN_ === i) break; + var i = _dO_; } } - return 0; + return; /*<>*/ } function bprint_fmtty(buf, fmtty){ /*<>*/ var fmtty$0 = fmtty; /*<>*/ for(;;){ if(typeof fmtty$0 === "number") - /*<>*/ return 0; + /*<>*/ return; switch(fmtty$0[0]){ case 0: var fmtty$1 = fmtty$0[1]; @@ -14587,7 +14625,7 @@ ign_flag$0 = ign_flag; /*<>*/ for(;;){ if(typeof fmt$0 === "number") - /*<>*/ return 0; + /*<>*/ return; switch(fmt$0[0]){ case 0: var rest = fmt$0[1]; @@ -14790,12 +14828,18 @@ c = /*<>*/ caml_call1 (Stdlib[29], i); - return 37 === c - ? (buffer_add_char(buf, 37), buffer_add_char(buf, 37)) - : 64 - === c - ? (buffer_add_char(buf, 37), buffer_add_char(buf, 64)) - : buffer_add_char(buf, c); + if(37 === c){ + /*<>*/ buffer_add_char(buf, 37); + /*<>*/ buffer_add_char(buf, 37); + /*<>*/ return; + } + if(64 === c){ + /*<>*/ buffer_add_char(buf, 37); + /*<>*/ buffer_add_char(buf, 64); + /*<>*/ return; + } + /*<>*/ buffer_add_char(buf, c); + /*<>*/ return; /*<>*/ }; /*<>*/ buffer_add_char(buf, 91); /*<>*/ var @@ -14813,18 +14857,18 @@ /*<>*/ before = /*<>*/ caml_call1 (Stdlib_Char[1], c - 1 | 0), - /*<>*/ _dH_ = + /*<>*/ _dI_ = is_in_char_set(set, c); - /*<>*/ if(_dH_) + /*<>*/ if(_dI_) /*<>*/ var - /*<>*/ _dI_ = - is_in_char_set(set, before), /*<>*/ _dJ_ = - _dI_ ? is_in_char_set(set, after) : _dI_, - _dK_ = 1 - _dJ_; + is_in_char_set(set, before), + /*<>*/ _dK_ = + _dJ_ ? is_in_char_set(set, after) : _dJ_, + _dL_ = 1 - _dK_; else - var _dK_ = _dH_; - /*<>*/ return _dK_; + var _dL_ = _dI_; + /*<>*/ return _dL_; /*<>*/ } return is_alone; }, @@ -14958,12 +15002,12 @@ (buf, ign_flag$0); switch(counter){ case 0: - var _dD_ = 108; break; + var _dE_ = 108; break; case 1: - var _dD_ = 110; break; - default: var _dD_ = 78; + var _dE_ = 110; break; + default: var _dE_ = 78; } - /*<>*/ buffer_add_char(buf, _dD_); + /*<>*/ buffer_add_char(buf, _dE_); var fmt$0 = rest$20, ign_flag$0 = 0; break; case 22: @@ -14987,20 +15031,20 @@ /*<>*/ var rest$23 = fmt$0[3], arity = fmt$0[1], - /*<>*/ _dF_ = + /*<>*/ _dG_ = int_of_custom_arity(arity), - _dE_ = 1; - if(_dF_ >= 1){ - var i$8 = _dE_; + _dF_ = 1; + if(_dG_ >= 1){ + var i$8 = _dF_; for(;;){ /*<>*/ buffer_add_char(buf, 37); /*<>*/ bprint_ignored_flag (buf, ign_flag$0); /*<>*/ buffer_add_char(buf, 63); /*<>*/ /*<>*/ var - _dG_ = i$8 + 1 | 0; - if(_dF_ === i$8) break; - var i$8 = _dG_; + _dH_ = i$8 + 1 | 0; + if(_dG_ === i$8) break; + var i$8 = _dH_; } } var fmt$0 = rest$23, ign_flag$0 = 0; @@ -15072,17 +15116,17 @@ ed = match[3], af = match[2], fa = match[1], - _di_ = + _dj_ = function(param){ /*<>*/ af(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _di_, + _dj_, ed, de]; case 1: @@ -15093,17 +15137,17 @@ ed$0 = match$0[3], af$0 = match$0[2], fa$0 = match$0[1], - _dj_ = + _dk_ = function(param){ /*<>*/ af$0(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$0(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dj_, + _dk_, ed$0, de$0]; case 2: @@ -15114,17 +15158,17 @@ ed$1 = match$1[3], af$1 = match$1[2], fa$1 = match$1[1], - _dk_ = + _dl_ = function(param){ /*<>*/ af$1(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$1(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dk_, + _dl_, ed$1, de$1]; case 3: @@ -15135,17 +15179,17 @@ ed$2 = match$2[3], af$2 = match$2[2], fa$2 = match$2[1], - _dl_ = + _dm_ = function(param){ /*<>*/ af$2(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$2(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dl_, + _dm_, ed$2, de$2]; case 4: @@ -15156,17 +15200,17 @@ ed$3 = match$3[3], af$3 = match$3[2], fa$3 = match$3[1], - _dm_ = + _dn_ = function(param){ /*<>*/ af$3(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$3(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dm_, + _dn_, ed$3, de$3]; case 5: @@ -15177,17 +15221,17 @@ ed$4 = match$4[3], af$4 = match$4[2], fa$4 = match$4[1], - _dn_ = + _do_ = function(param){ /*<>*/ af$4(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$4(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dn_, + _do_, ed$4, de$4]; case 6: @@ -15198,17 +15242,17 @@ ed$5 = match$5[3], af$5 = match$5[2], fa$5 = match$5[1], - _do_ = + _dp_ = function(param){ /*<>*/ af$5(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$5(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _do_, + _dp_, ed$5, de$5]; case 7: @@ -15219,17 +15263,17 @@ ed$6 = match$6[3], af$6 = match$6[2], fa$6 = match$6[1], - _dp_ = + _dq_ = function(param){ /*<>*/ af$6(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$6(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dp_, + _dq_, ed$6, de$6]; case 8: @@ -15240,17 +15284,17 @@ ed$7 = match$7[3], af$7 = match$7[2], fa$7 = match$7[1], - _dq_ = + _dr_ = function(param){ /*<>*/ af$7(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$7(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dq_, + _dr_, ed$7, de$7]; case 9: @@ -15269,33 +15313,33 @@ dj = match$9[3], ga = match$9[2], ag = match$9[1], - _dr_ = + _ds_ = function(param){ /*<>*/ jd(0); /*<>*/ de$8(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _ds_ = + _dt_ = function(param){ /*<>*/ ed$8(0); /*<>*/ dj(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dt_ = + _du_ = function(param){ /*<>*/ ga(0); /*<>*/ af$8(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$8(0); /*<>*/ ag(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, + _du_, _dt_, - _ds_, - _dr_]; + _ds_]; case 10: /*<>*/ var rest$9 = param[1], @@ -15305,17 +15349,17 @@ ed$9 = match$10[3], af$9 = match$10[2], fa$9 = match$10[1], - _du_ = + _dv_ = function(param){ /*<>*/ af$9(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$9(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _du_, + _dv_, ed$9, de$9]; case 11: @@ -15327,17 +15371,17 @@ ed$10 = match$11[3], af$10 = match$11[2], fa$10 = match$11[1], - _dv_ = + _dw_ = function(param){ /*<>*/ af$10(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$10(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dv_, + _dw_, ed$10, de$10]; case 12: @@ -15349,17 +15393,17 @@ ed$11 = match$12[3], af$11 = match$12[2], fa$11 = match$12[1], - _dw_ = + _dx_ = function(param){ /*<>*/ af$11(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$11(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dw_, + _dx_, ed$11, de$11]; case 13: @@ -15371,29 +15415,29 @@ ed$12 = match$13[3], af$12 = match$13[2], fa$12 = match$13[1], - /*<>*/ _dx_ = + /*<>*/ _dy_ = function(param){ /*<>*/ de$12(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dy_ = + _dz_ = function(param){ /*<>*/ ed$12(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dz_ = + _dA_ = function(param){ /*<>*/ af$12(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$12(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, + _dA_, _dz_, - _dy_, - _dx_]; + _dy_]; default: /*<>*/ var rest$13 = param[1], @@ -15403,46 +15447,46 @@ ed$13 = match$14[3], af$13 = match$14[2], fa$13 = match$14[1], - /*<>*/ _dA_ = + /*<>*/ _dB_ = function(param){ /*<>*/ de$13(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dB_ = + _dC_ = function(param){ /*<>*/ ed$13(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - _dC_ = + _dD_ = function(param){ /*<>*/ af$13(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }; /*<>*/ return [0, function(param){ /*<>*/ fa$13(0); - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, + _dD_, _dC_, - _dB_, - _dA_]; + _dB_]; } - /*<>*/ function _df_(param){ - /*<>*/ return 0; + /*<>*/ function _dg_(param){ + /*<>*/ return; /*<>*/ } - function _dg_(param){ - /*<>*/ return 0; - /*<>*/ } function _dh_(param){ - /*<>*/ return 0; + /*<>*/ return; + /*<>*/ } + function _di_(param){ + /*<>*/ return; /*<>*/ } /*<>*/ return [0, function(param){ - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, + _di_, _dh_, - _dg_, - _df_]; + _dg_]; } function trans(ty1, ty2){ /*<>*/ a: @@ -15661,11 +15705,11 @@ /*<>*/ var rest2$7 = ty2[2], ty2$0 = ty2[1], - /*<>*/ _de_ = + /*<>*/ _df_ = trans(rest1$7, rest2$7); /*<>*/ return [8, trans(ty1$0, ty2$0), - _de_]; + _df_]; case 10: break a; case 11: @@ -15955,13 +15999,13 @@ /*<>*/ var rest$13 = fmtty$0[2], formatting_gen = fmtty$0[1], - /*<>*/ _db_ = fmtty_of_fmt(rest$13); + /*<>*/ _dc_ = fmtty_of_fmt(rest$13); if(0 === formatting_gen[0]) - var fmt = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt); + var fmt = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt); else - var fmt$0 = formatting_gen[1][1], _dc_ = fmtty_of_fmt(fmt$0); + var fmt$0 = formatting_gen[1][1], _dd_ = fmtty_of_fmt(fmt$0); /*<>*/ return /*<>*/ caml_call2 - (CamlinternalFormatBasics[1], _dc_, _db_); + (CamlinternalFormatBasics[1], _dd_, _dc_); case 19: var rest$14 = fmtty$0[1]; /*<>*/ return [13, @@ -16014,10 +16058,10 @@ case 9: /*<>*/ var fmtty$6 = ign[2], - /*<>*/ _dd_ = + /*<>*/ _de_ = fmtty_of_fmt(fmtty$5); /*<>*/ return /*<>*/ caml_call2 - (CamlinternalFormatBasics[1], fmtty$6, _dd_); + (CamlinternalFormatBasics[1], fmtty$6, _de_); case 10: var fmtty$0 = fmtty$5; break; default: var fmtty$0 = fmtty$5; @@ -16073,11 +16117,11 @@ /*<>*/ } function type_format(fmt, fmtty){ /*<>*/ /*<>*/ var - _da_ = type_format_gen(fmt, fmtty); - if(typeof _da_[2] !== "number") + _db_ = type_format_gen(fmt, fmtty); + if(typeof _db_[2] !== "number") /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace (Type_mismatch, 1); - var fmt$0 = _da_[1]; + var fmt$0 = _db_[1]; /*<>*/ return fmt$0; /*<>*/ } function type_ignored_param_one(ign, fmt, fmtty){ @@ -16362,7 +16406,7 @@ fmt_rest$13 = fmt[3], sub_fmtty$1 = fmt[2], pad_opt$0 = fmt[1], - /*<>*/ _c__ = + /*<>*/ _c$_ = [0, /*<>*/ caml_call1 (CamlinternalFormatBasics[2], sub_fmtty1)]; @@ -16371,7 +16415,7 @@ ([0, /*<>*/ caml_call1 (CamlinternalFormatBasics[2], sub_fmtty$1)], - _c__)) + _c$_)) /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace (Type_mismatch, 1); /*<>*/ var @@ -16541,12 +16585,12 @@ /*<>*/ var sub_fmtty$3 = ign[2], pad_opt$2 = ign[1], - /*<>*/ _c$_ = + /*<>*/ _da_ = type_ignored_format_substituti(sub_fmtty$3, rest, fmtty0), - match$43 = _c$_[2], + match$43 = _da_[2], fmtty$21 = match$43[2], fmt$22 = match$43[1], - sub_fmtty$4 = _c$_[1]; + sub_fmtty$4 = _da_[1]; /*<>*/ return [0, [23, [9, pad_opt$2, sub_fmtty$4], fmt$22], fmtty$21]; @@ -16738,7 +16782,7 @@ sub_fmtty_rest$17 = sub_fmtty[3], sub2_fmtty$2 = sub_fmtty[2], sub1_fmtty$0 = sub_fmtty[1], - /*<>*/ _c8_ = + /*<>*/ _c9_ = [0, /*<>*/ caml_call1 (CamlinternalFormatBasics[2], sub1_fmtty)]; @@ -16747,11 +16791,11 @@ ([0, /*<>*/ caml_call1 (CamlinternalFormatBasics[2], sub1_fmtty$0)], - _c8_)) + _c9_)) /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace (Type_mismatch, 1); /*<>*/ /*<>*/ var - _c9_ = + _c__ = [0, /*<>*/ caml_call1 (CamlinternalFormatBasics[2], sub2_fmtty$1)]; @@ -16760,7 +16804,7 @@ ([0, /*<>*/ caml_call1 (CamlinternalFormatBasics[2], sub2_fmtty$2)], - _c9_)) + _c__)) /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace (Type_mismatch, 1); /*<>*/ var @@ -16852,11 +16896,11 @@ /*<>*/ } function recast(fmt, fmtty){ /*<>*/ /*<>*/ var - _c7_ = symm(fmtty); + _c8_ = symm(fmtty); /*<>*/ return type_format (fmt, /*<>*/ caml_call1 - (CamlinternalFormatBasics[2], _c7_)); + (CamlinternalFormatBasics[2], _c8_)); /*<>*/ } function fix_padding(padty, width, str){ /*<>*/ var @@ -16866,10 +16910,10 @@ /*<>*/ caml_call1(Stdlib[18], width); if(width$0 <= len) /*<>*/ return str; /*<>*/ var - _c6_ = 2 === padty$0 ? 48 : 32, + _c7_ = 2 === padty$0 ? 48 : 32, /*<>*/ res = /*<>*/ caml_call2 - (Stdlib_Bytes[1], width$0, _c6_); + (Stdlib_Bytes[1], width$0, _c7_); /*<>*/ switch(padty$0){ case 0: /*<>*/ /*<>*/ caml_call5 @@ -17061,16 +17105,16 @@ /*<>*/ return s; /*<>*/ var /*<>*/ n = [0, 0], - _c1_ = caml_ml_string_length(s) - 1 | 0, - /*<>*/ _c0_ = 0; - if(_c1_ >= 0){ - var i$0 = _c0_; + _c2_ = caml_ml_string_length(s) - 1 | 0, + /*<>*/ _c1_ = 0; + if(_c2_ >= 0){ + var i$0 = _c1_; for(;;){ if(9 >= caml_string_unsafe_get(s, i$0) - 48 >>> 0) n[1]++; /*<>*/ /*<>*/ var - _c5_ = i$0 + 1 | 0; - if(_c1_ === i$0) break; - var i$0 = _c5_; + _c6_ = i$0 + 1 | 0; + if(_c2_ === i$0) break; + var i$0 = _c6_; } } /*<>*/ var @@ -17083,15 +17127,15 @@ /*<>*/ /*<>*/ caml_bytes_set (buf, pos[1], c); pos[1]++; - return 0; + return; /*<>*/ } /*<>*/ var /*<>*/ left = [0, ((digits - 1 | 0) % 3 | 0) + 1 | 0], - _c3_ = caml_ml_string_length(s) - 1 | 0, - /*<>*/ _c2_ = 0; - if(_c3_ >= 0){ - var i = _c2_; + _c4_ = caml_ml_string_length(s) - 1 | 0, + /*<>*/ _c3_ = 0; + if(_c4_ >= 0){ + var i = _c3_; for(;;){ var c = caml_string_unsafe_get(s, i); if(9 < c - 48 >>> 0) @@ -17105,9 +17149,9 @@ /*<>*/ put(c); } /*<>*/ /*<>*/ var - _c4_ = i + 1 | 0; - if(_c3_ === i) break; - var i = _c4_; + _c5_ = i + 1 | 0; + if(_c4_ === i) break; + var i = _c5_; } } /*<>*/ return /*<>*/ caml_call1 @@ -17116,139 +17160,139 @@ function convert_int(iconv, n){ /*<>*/ switch(iconv){ case 1: - var _cZ_ = cst_d$0; break; + var _c0_ = cst_d$0; break; case 2: - var _cZ_ = cst_d$1; break; + var _c0_ = cst_d$1; break; case 4: - var _cZ_ = cst_i$1; break; + var _c0_ = cst_i$1; break; case 5: - var _cZ_ = cst_i$2; break; + var _c0_ = cst_i$2; break; case 6: - var _cZ_ = cst_x; break; + var _c0_ = cst_x; break; case 7: - var _cZ_ = cst_x$0; break; + var _c0_ = cst_x$0; break; case 8: - var _cZ_ = cst_X; break; + var _c0_ = cst_X; break; case 9: - var _cZ_ = cst_X$0; break; + var _c0_ = cst_X$0; break; case 10: - var _cZ_ = cst_o; break; + var _c0_ = cst_o; break; case 11: - var _cZ_ = cst_o$0; break; + var _c0_ = cst_o$0; break; case 0: case 13: - var _cZ_ = cst_d; break; + var _c0_ = cst_d; break; case 3: case 14: - var _cZ_ = cst_i$0; break; - default: var _cZ_ = cst_u; + var _c0_ = cst_i$0; break; + default: var _c0_ = cst_u; } /*<>*/ return transform_int_alt (iconv, - /*<>*/ caml_format_int(_cZ_, n)); + /*<>*/ caml_format_int(_c0_, n)); /*<>*/ } function convert_int32(iconv, n){ /*<>*/ switch(iconv){ case 1: - var _cY_ = cst_ld$0; break; + var _cZ_ = cst_ld$0; break; case 2: - var _cY_ = cst_ld$1; break; + var _cZ_ = cst_ld$1; break; case 4: - var _cY_ = cst_li$1; break; + var _cZ_ = cst_li$1; break; case 5: - var _cY_ = cst_li$2; break; + var _cZ_ = cst_li$2; break; case 6: - var _cY_ = cst_lx; break; + var _cZ_ = cst_lx; break; case 7: - var _cY_ = cst_lx$0; break; + var _cZ_ = cst_lx$0; break; case 8: - var _cY_ = cst_lX; break; + var _cZ_ = cst_lX; break; case 9: - var _cY_ = cst_lX$0; break; + var _cZ_ = cst_lX$0; break; case 10: - var _cY_ = cst_lo; break; + var _cZ_ = cst_lo; break; case 11: - var _cY_ = cst_lo$0; break; + var _cZ_ = cst_lo$0; break; case 0: case 13: - var _cY_ = cst_ld; break; + var _cZ_ = cst_ld; break; case 3: case 14: - var _cY_ = cst_li$0; break; - default: var _cY_ = cst_lu; + var _cZ_ = cst_li$0; break; + default: var _cZ_ = cst_lu; } /*<>*/ return transform_int_alt (iconv, - /*<>*/ caml_format_int(_cY_, n)); + /*<>*/ caml_format_int(_cZ_, n)); /*<>*/ } function convert_nativeint(iconv, n){ /*<>*/ switch(iconv){ case 1: - var _cX_ = cst_nd$0; break; + var _cY_ = cst_nd$0; break; case 2: - var _cX_ = cst_nd$1; break; + var _cY_ = cst_nd$1; break; case 4: - var _cX_ = cst_ni$1; break; + var _cY_ = cst_ni$1; break; case 5: - var _cX_ = cst_ni$2; break; + var _cY_ = cst_ni$2; break; case 6: - var _cX_ = cst_nx; break; + var _cY_ = cst_nx; break; case 7: - var _cX_ = cst_nx$0; break; + var _cY_ = cst_nx$0; break; case 8: - var _cX_ = cst_nX; break; + var _cY_ = cst_nX; break; case 9: - var _cX_ = cst_nX$0; break; + var _cY_ = cst_nX$0; break; case 10: - var _cX_ = cst_no; break; + var _cY_ = cst_no; break; case 11: - var _cX_ = cst_no$0; break; + var _cY_ = cst_no$0; break; case 0: case 13: - var _cX_ = cst_nd; break; + var _cY_ = cst_nd; break; case 3: case 14: - var _cX_ = cst_ni$0; break; - default: var _cX_ = cst_nu; + var _cY_ = cst_ni$0; break; + default: var _cY_ = cst_nu; } /*<>*/ return transform_int_alt (iconv, - /*<>*/ caml_format_int(_cX_, n)); + /*<>*/ caml_format_int(_cY_, n)); /*<>*/ } function convert_int64(iconv, n){ /*<>*/ switch(iconv){ case 1: - var _cW_ = cst_Ld$0; break; + var _cX_ = cst_Ld$0; break; case 2: - var _cW_ = cst_Ld$1; break; + var _cX_ = cst_Ld$1; break; case 4: - var _cW_ = cst_Li$1; break; + var _cX_ = cst_Li$1; break; case 5: - var _cW_ = cst_Li$2; break; + var _cX_ = cst_Li$2; break; case 6: - var _cW_ = cst_Lx; break; + var _cX_ = cst_Lx; break; case 7: - var _cW_ = cst_Lx$0; break; + var _cX_ = cst_Lx$0; break; case 8: - var _cW_ = cst_LX; break; + var _cX_ = cst_LX; break; case 9: - var _cW_ = cst_LX$0; break; + var _cX_ = cst_LX$0; break; case 10: - var _cW_ = cst_Lo; break; + var _cX_ = cst_Lo; break; case 11: - var _cW_ = cst_Lo$0; break; + var _cX_ = cst_Lo$0; break; case 0: case 13: - var _cW_ = cst_Ld; break; + var _cX_ = cst_Ld; break; case 3: case 14: - var _cW_ = cst_Li$0; break; - default: var _cW_ = cst_Lu; + var _cX_ = cst_Li$0; break; + default: var _cX_ = cst_Lu; } /*<>*/ return transform_int_alt (iconv, /*<>*/ runtime.caml_int64_format - (_cW_, n)); + (_cX_, n)); /*<>*/ } function convert_float(fconv, prec, x){ function hex(param){ @@ -17280,41 +17324,41 @@ i = 0; /*<>*/ for(;;){ if(i === len) - var _cT_ = 0; + var _cU_ = 0; else{ /*<>*/ /*<>*/ var - _cS_ = + _cT_ = /*<>*/ caml_string_get(str, i) - 46 | 0; a: { - if(23 < _cS_ >>> 0){ - if(55 === _cS_) break a; + if(23 < _cT_ >>> 0){ + if(55 === _cT_) break a; } - else if(21 < _cS_ - 1 >>> 0) break a; + else if(21 < _cT_ - 1 >>> 0) break a; /*<>*/ var /*<>*/ i$0 = i + 1 | 0, i = i$0; continue; } - var _cT_ = 1; + var _cU_ = 1; } /*<>*/ /*<>*/ var - _cU_ = - _cT_ + _cV_ = + _cU_ ? str : /*<>*/ caml_call2 (Stdlib[28], str, cst$17); - /*<>*/ return caml_special_val(_cU_); + /*<>*/ return caml_special_val(_cV_); } case 6: /*<>*/ return hex(0); case 7: /*<>*/ /*<>*/ var - _cV_ = hex(0); + _cW_ = hex(0); /*<>*/ return /*<>*/ caml_call1 - (Stdlib_String[26], _cV_); + (Stdlib_String[26], _cW_); case 8: /*<>*/ return caml_special_val(hex(0)); default: @@ -17699,12 +17743,12 @@ /*<>*/ return function(param){ /*<>*/ var fmt = param[1], - /*<>*/ _cR_ = recast(fmt, fmtty); + /*<>*/ _cS_ = recast(fmt, fmtty); /*<>*/ return make_printf (k$0, acc$0, /*<>*/ caml_call2 - (CamlinternalFormatBasics[3], _cR_, rest$13)); /*<>*/ }; + (CamlinternalFormatBasics[3], _cS_, rest$13)); /*<>*/ }; case 15: var rest$14 = fmt$0[1]; /*<>*/ return function(f, x){ @@ -17731,11 +17775,11 @@ fmt$0 = rest$16; break; case 18: - var _cP_ = fmt$0[1]; - if(0 === _cP_[0]) + var _cQ_ = fmt$0[1]; + if(0 === _cQ_[0]) var rest$17 = fmt$0[2], - fmt$1 = _cP_[1][1], + fmt$1 = _cQ_[1][1], k$3 = function(acc, k, rest){ function k$0(kacc){ @@ -17751,7 +17795,7 @@ else var rest$18 = fmt$0[2], - fmt$2 = _cP_[1][1], + fmt$2 = _cQ_[1][1], k$4 = function(acc, k, rest){ function k$0(kacc){ @@ -17807,14 +17851,14 @@ rest$23 = fmt$0[3], f = fmt$0[2], arity = fmt$0[1], - /*<>*/ _cQ_ = + /*<>*/ _cR_ = /*<>*/ caml_call1(f, 0); /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return - (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cQ_]); + (make_custom$0, [0, k$0, acc$0, rest$23, arity, _cR_]); var counter$0 = counter + 1 | 0; /*<>*/ return make_custom$0 - (counter$0, k$0, acc$0, rest$23, arity, _cQ_); + (counter$0, k$0, acc$0, rest$23, arity, _cR_); } } /*<>*/ } @@ -17997,7 +18041,7 @@ fmt); /*<>*/ }; case 10: var rest$9 = fmtty[1]; - /*<>*/ return function(param, _cO_){ + /*<>*/ return function(param, _cP_){ /*<>*/ return make_from_fmtty (k, acc, rest$9, fmt); /*<>*/ }; case 11: @@ -18026,13 +18070,13 @@ /*<>*/ } function make_invalid_arg(counter, k, acc, fmt){ /*<>*/ /*<>*/ var - _cN_ = [8, acc, cst_Printf_bad_conversion$0]; + _cO_ = [8, acc, cst_Printf_bad_conversion$0]; /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return - (make_printf$0, [0, k, _cN_, fmt]); + (make_printf$0, [0, k, _cO_, fmt]); var counter$0 = counter + 1 | 0; /*<>*/ return make_printf$0 - (counter$0, k, _cN_, fmt); + (counter$0, k, _cO_, fmt); /*<>*/ } function make_custom$0(counter, k, acc, rest, arity, f){ /*<>*/ if(arity){ @@ -18046,13 +18090,13 @@ /*<>*/ caml_call1(f, x)); /*<>*/ }; } /*<>*/ /*<>*/ var - _cM_ = [4, acc, f]; + _cN_ = [4, acc, f]; /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return - (make_printf$0, [0, k, _cM_, rest]); + (make_printf$0, [0, k, _cN_, rest]); var counter$0 = counter + 1 | 0; /*<>*/ return make_printf$0 - (counter$0, k, _cM_, rest); + (counter$0, k, _cN_, rest); /*<>*/ } function make_printf(k, acc, fmt){ /*<>*/ return caml_trampoline(make_printf$0(0, k, acc, fmt)); @@ -18073,68 +18117,68 @@ /*<>*/ if(typeof pad === "number"){ if(typeof prec !== "number"){ /*<>*/ /*<>*/ var - _cl_ = make_iprintf(k, o, fmt); - /*<>*/ return function(_cL_){ - /*<>*/ return _cl_;}; + _cm_ = make_iprintf(k, o, fmt); + /*<>*/ return function(_cM_){ + /*<>*/ return _cm_;}; } if(prec){ /*<>*/ var - /*<>*/ _ci_ = make_iprintf(k, o, fmt), - /*<>*/ _cj_ = - function(_cK_){ /*<>*/ return _ci_;}; - /*<>*/ return function(_cJ_){ - /*<>*/ return _cj_;}; + /*<>*/ _cj_ = make_iprintf(k, o, fmt), + /*<>*/ _ck_ = + function(_cL_){ /*<>*/ return _cj_;}; + /*<>*/ return function(_cK_){ + /*<>*/ return _ck_;}; } /*<>*/ /*<>*/ var - _ck_ = make_iprintf(k, o, fmt); - /*<>*/ return function(_cI_){ - /*<>*/ return _ck_;}; + _cl_ = make_iprintf(k, o, fmt); + /*<>*/ return function(_cJ_){ + /*<>*/ return _cl_;}; } if(0 === pad[0]){ if(typeof prec !== "number"){ /*<>*/ /*<>*/ var - _cp_ = make_iprintf(k, o, fmt); - /*<>*/ return function(_cH_){ - /*<>*/ return _cp_;}; + _cq_ = make_iprintf(k, o, fmt); + /*<>*/ return function(_cI_){ + /*<>*/ return _cq_;}; } if(prec){ /*<>*/ var - /*<>*/ _cm_ = make_iprintf(k, o, fmt), - /*<>*/ _cn_ = - function(_cG_){ /*<>*/ return _cm_;}; - /*<>*/ return function(_cF_){ - /*<>*/ return _cn_;}; + /*<>*/ _cn_ = make_iprintf(k, o, fmt), + /*<>*/ _co_ = + function(_cH_){ /*<>*/ return _cn_;}; + /*<>*/ return function(_cG_){ + /*<>*/ return _co_;}; } /*<>*/ /*<>*/ var - _co_ = make_iprintf(k, o, fmt); - /*<>*/ return function(_cE_){ - /*<>*/ return _co_;}; + _cp_ = make_iprintf(k, o, fmt); + /*<>*/ return function(_cF_){ + /*<>*/ return _cp_;}; } if(typeof prec !== "number"){ /*<>*/ var - /*<>*/ _cv_ = make_iprintf(k, o, fmt), - /*<>*/ _cw_ = - function(_cD_){ /*<>*/ return _cv_;}; - /*<>*/ return function(_cC_){ - /*<>*/ return _cw_;}; + /*<>*/ _cw_ = make_iprintf(k, o, fmt), + /*<>*/ _cx_ = + function(_cE_){ /*<>*/ return _cw_;}; + /*<>*/ return function(_cD_){ + /*<>*/ return _cx_;}; } if(prec){ /*<>*/ var - /*<>*/ _cq_ = make_iprintf(k, o, fmt), - /*<>*/ _cr_ = - function(_cB_){ /*<>*/ return _cq_;}, - /*<>*/ _cs_ = - function(_cA_){ /*<>*/ return _cr_;}; - /*<>*/ return function(_cz_){ - /*<>*/ return _cs_;}; + /*<>*/ _cr_ = make_iprintf(k, o, fmt), + /*<>*/ _cs_ = + function(_cC_){ /*<>*/ return _cr_;}, + /*<>*/ _ct_ = + function(_cB_){ /*<>*/ return _cs_;}; + /*<>*/ return function(_cA_){ + /*<>*/ return _ct_;}; } /*<>*/ /*<>*/ var - _ct_ = make_iprintf(k, o, fmt); - /*<>*/ function _cu_(_cy_){ - /*<>*/ return _ct_; + _cu_ = make_iprintf(k, o, fmt); + /*<>*/ function _cv_(_cz_){ + /*<>*/ return _cu_; } - /*<>*/ return function(_cx_){ - /*<>*/ return _cu_;}; + /*<>*/ return function(_cy_){ + /*<>*/ return _cv_;}; /*<>*/ } function make_iprintf$0(counter, k, o, fmt){ /*<>*/ var k$0 = k, fmt$0 = fmt; @@ -18146,69 +18190,69 @@ case 0: /*<>*/ var rest = fmt$0[1], - /*<>*/ _by_ = + /*<>*/ _bz_ = make_iprintf(k$0, o, rest); - /*<>*/ return function(_ch_){ - /*<>*/ return _by_;}; + /*<>*/ return function(_ci_){ + /*<>*/ return _bz_;}; case 1: /*<>*/ var rest$0 = fmt$0[1], - /*<>*/ _bz_ = + /*<>*/ _bA_ = make_iprintf(k$0, o, rest$0); - /*<>*/ return function(_cg_){ - /*<>*/ return _bz_;}; + /*<>*/ return function(_ch_){ + /*<>*/ return _bA_;}; case 2: - var _bA_ = fmt$0[1]; - if(typeof _bA_ === "number"){ + var _bB_ = fmt$0[1]; + if(typeof _bB_ === "number"){ /*<>*/ var rest$1 = fmt$0[2], - /*<>*/ _bB_ = + /*<>*/ _bC_ = make_iprintf(k$0, o, rest$1); - /*<>*/ return function(_cf_){ - /*<>*/ return _bB_;}; + /*<>*/ return function(_cg_){ + /*<>*/ return _bC_;}; } - if(0 === _bA_[0]){ + if(0 === _bB_[0]){ /*<>*/ var rest$2 = fmt$0[2], - /*<>*/ _bC_ = + /*<>*/ _bD_ = make_iprintf(k$0, o, rest$2); - /*<>*/ return function(_ce_){ - /*<>*/ return _bC_;}; + /*<>*/ return function(_cf_){ + /*<>*/ return _bD_;}; } /*<>*/ var rest$3 = fmt$0[2], - /*<>*/ _bD_ = + /*<>*/ _bE_ = make_iprintf(k$0, o, rest$3), - /*<>*/ _bE_ = - function(_cd_){ /*<>*/ return _bD_;}; - /*<>*/ return function(_cc_){ - /*<>*/ return _bE_;}; + /*<>*/ _bF_ = + function(_ce_){ /*<>*/ return _bE_;}; + /*<>*/ return function(_cd_){ + /*<>*/ return _bF_;}; case 3: - var _bF_ = fmt$0[1]; - if(typeof _bF_ === "number"){ + var _bG_ = fmt$0[1]; + if(typeof _bG_ === "number"){ /*<>*/ var rest$4 = fmt$0[2], - /*<>*/ _bG_ = + /*<>*/ _bH_ = make_iprintf(k$0, o, rest$4); - /*<>*/ return function(_cb_){ - /*<>*/ return _bG_;}; + /*<>*/ return function(_cc_){ + /*<>*/ return _bH_;}; } - if(0 === _bF_[0]){ + if(0 === _bG_[0]){ /*<>*/ var rest$5 = fmt$0[2], - /*<>*/ _bH_ = + /*<>*/ _bI_ = make_iprintf(k$0, o, rest$5); - /*<>*/ return function(_ca_){ - /*<>*/ return _bH_;}; + /*<>*/ return function(_cb_){ + /*<>*/ return _bI_;}; } /*<>*/ var rest$6 = fmt$0[2], - /*<>*/ _bI_ = + /*<>*/ _bJ_ = make_iprintf(k$0, o, rest$6), - /*<>*/ _bJ_ = - function(_b$_){ /*<>*/ return _bI_;}; - /*<>*/ return function(_b__){ - /*<>*/ return _bJ_;}; + /*<>*/ _bK_ = + function(_ca_){ /*<>*/ return _bJ_;}; + /*<>*/ return function(_b$_){ + /*<>*/ return _bK_;}; case 4: var rest$7 = fmt$0[4], prec = fmt$0[3], pad = fmt$0[2]; /*<>*/ return fn_of_padding_precision @@ -18230,31 +18274,31 @@ /*<>*/ return fn_of_padding_precision (k$0, o, rest$11, pad$3, prec$3); case 9: - var _bK_ = fmt$0[1]; - if(typeof _bK_ === "number"){ + var _bL_ = fmt$0[1]; + if(typeof _bL_ === "number"){ /*<>*/ var rest$12 = fmt$0[2], - /*<>*/ _bL_ = + /*<>*/ _bM_ = make_iprintf(k$0, o, rest$12); - /*<>*/ return function(_b9_){ - /*<>*/ return _bL_;}; + /*<>*/ return function(_b__){ + /*<>*/ return _bM_;}; } - if(0 === _bK_[0]){ + if(0 === _bL_[0]){ /*<>*/ var rest$13 = fmt$0[2], - /*<>*/ _bM_ = + /*<>*/ _bN_ = make_iprintf(k$0, o, rest$13); - /*<>*/ return function(_b8_){ - /*<>*/ return _bM_;}; + /*<>*/ return function(_b9_){ + /*<>*/ return _bN_;}; } /*<>*/ var rest$14 = fmt$0[2], - /*<>*/ _bN_ = + /*<>*/ _bO_ = make_iprintf(k$0, o, rest$14), - /*<>*/ _bO_ = - function(_b7_){ /*<>*/ return _bN_;}; - /*<>*/ return function(_b6_){ - /*<>*/ return _bO_;}; + /*<>*/ _bP_ = + function(_b8_){ /*<>*/ return _bO_;}; + /*<>*/ return function(_b7_){ + /*<>*/ return _bP_;}; case 10: var rest$15 = fmt$0[1], fmt$0 = rest$15; break; case 11: @@ -18264,45 +18308,45 @@ case 13: /*<>*/ var rest$18 = fmt$0[3], - /*<>*/ _bP_ = + /*<>*/ _bQ_ = make_iprintf(k$0, o, rest$18); - /*<>*/ return function(_b5_){ - /*<>*/ return _bP_;}; + /*<>*/ return function(_b6_){ + /*<>*/ return _bQ_;}; case 14: var rest$19 = fmt$0[3], fmtty = fmt$0[2]; /*<>*/ return function(param){ /*<>*/ var fmt = param[1], - /*<>*/ _b4_ = recast(fmt, fmtty); + /*<>*/ _b5_ = recast(fmt, fmtty); /*<>*/ return make_iprintf (k$0, o, /*<>*/ caml_call2 - (CamlinternalFormatBasics[3], _b4_, rest$19)); /*<>*/ }; + (CamlinternalFormatBasics[3], _b5_, rest$19)); /*<>*/ }; case 15: /*<>*/ var rest$20 = fmt$0[1], - /*<>*/ _bQ_ = + /*<>*/ _bR_ = make_iprintf(k$0, o, rest$20), - /*<>*/ _bR_ = - function(_b3_){ /*<>*/ return _bQ_;}; - /*<>*/ return function(_b2_){ - /*<>*/ return _bR_;}; + /*<>*/ _bS_ = + function(_b4_){ /*<>*/ return _bR_;}; + /*<>*/ return function(_b3_){ + /*<>*/ return _bS_;}; case 16: /*<>*/ var rest$21 = fmt$0[1], - /*<>*/ _bS_ = + /*<>*/ _bT_ = make_iprintf(k$0, o, rest$21); - /*<>*/ return function(_b1_){ - /*<>*/ return _bS_;}; + /*<>*/ return function(_b2_){ + /*<>*/ return _bT_;}; case 17: var rest$22 = fmt$0[2], fmt$0 = rest$22; break; case 18: - var _bT_ = fmt$0[1]; - if(0 === _bT_[0]) + var _bU_ = fmt$0[1]; + if(0 === _bU_[0]) var rest$23 = fmt$0[2], - fmt$1 = _bT_[1][1], + fmt$1 = _bU_[1][1], k$3 = function(k, rest){ function k$0(koc){ @@ -18317,7 +18361,7 @@ else var rest$24 = fmt$0[2], - fmt$2 = _bT_[1][1], + fmt$2 = _bU_[1][1], k$4 = function(k, rest){ function k$0(koc){ @@ -18336,32 +18380,32 @@ case 20: /*<>*/ var rest$25 = fmt$0[3], - /*<>*/ _bU_ = + /*<>*/ _bV_ = make_iprintf(k$0, o, rest$25); - /*<>*/ return function(_b0_){ - /*<>*/ return _bU_;}; + /*<>*/ return function(_b1_){ + /*<>*/ return _bV_;}; case 21: /*<>*/ var rest$26 = fmt$0[2], - /*<>*/ _bV_ = + /*<>*/ _bW_ = make_iprintf(k$0, o, rest$26); - /*<>*/ return function(_bZ_){ - /*<>*/ return _bV_;}; + /*<>*/ return function(_b0_){ + /*<>*/ return _bW_;}; case 22: /*<>*/ var rest$27 = fmt$0[1], - /*<>*/ _bW_ = + /*<>*/ _bX_ = make_iprintf(k$0, o, rest$27); - /*<>*/ return function(_bY_){ - /*<>*/ return _bW_;}; + /*<>*/ return function(_bZ_){ + /*<>*/ return _bX_;}; case 23: - var rest$28 = fmt$0[2], ign = fmt$0[1], _bX_ = 0; + var rest$28 = fmt$0[2], ign = fmt$0[1], _bY_ = 0; /*<>*/ return make_ignored_param (function(param){ /*<>*/ return caml_call1 (k$0, o); /*<>*/ }, - _bX_, + _bY_, ign, rest$28); default: @@ -18379,10 +18423,10 @@ /*<>*/ if(param){ /*<>*/ var arity = param[1], - /*<>*/ _bw_ = + /*<>*/ _bx_ = fn_of_custom_arity(k, o, fmt, arity); - /*<>*/ return function(_bx_){ - /*<>*/ return _bw_;}; + /*<>*/ return function(_by_){ + /*<>*/ return _bx_;}; } /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return @@ -18553,9 +18597,9 @@ var f = acc$0[2], p$3 = acc$0[1]; /*<>*/ strput_acc(b, p$3); /*<>*/ /*<>*/ var - _bv_ = /*<>*/ caml_call1(f, 0); + _bw_ = /*<>*/ caml_call1(f, 0); /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Buffer[16], b, _bv_); + (Stdlib_Buffer[16], b, _bw_); case 7: var acc$3 = acc$0[1], acc$0 = acc$3; break; case 8: @@ -18586,11 +18630,11 @@ function k(acc){ /*<>*/ strput_acc(buf, acc); /*<>*/ /*<>*/ var - _bu_ = + _bv_ = /*<>*/ caml_call1 (Stdlib_Buffer[2], buf); /*<>*/ return /*<>*/ caml_call1 - (Stdlib[2], _bu_); + (Stdlib[2], _bv_); /*<>*/ } /*<>*/ return make_printf(k, 0, fmt); } @@ -18665,15 +18709,15 @@ else /*<>*/ try{ /*<>*/ var - /*<>*/ _bs_ = + /*<>*/ _bt_ = /*<>*/ runtime.caml_int_of_string ( /*<>*/ caml_call3 (Stdlib_String[16], str, nstart, nend - nstart | 0)), - indent = _bs_; + indent = _bt_; } - catch(_bt_){ - var _br_ = caml_wrap_exception(_bt_); - if(_br_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_br_, 0); + catch(_bu_){ + var _bs_ = caml_wrap_exception(_bu_); + if(_bs_[1] !== Stdlib[7]) throw caml_maybe_attach_backtrace(_bs_, 0); var indent = invalid_box(0); } /*<>*/ /*<>*/ var @@ -18713,9 +18757,9 @@ /*<>*/ } function make_padprec_fmt_ebb(pad, prec, fmt){ /*<>*/ if(typeof prec === "number") - var match = prec ? [0, 1, fmt] : [0, 0, fmt]; + var match = prec ? [0, 1] : [0, 0]; else - var p = prec[1], match = [0, [0, p], fmt]; + var p = prec[1], match = [0, [0, p]]; var prec$0 = match[1]; /*<>*/ if(typeof pad === "number") /*<>*/ return [0, 0, prec$0, fmt]; @@ -18737,8 +18781,9 @@ /*<>*/ } /*<>*/ function unexpected_end_of_format (end_ind){ - /*<>*/ return invalid_format_message - (end_ind, cst_unexpected_end_of_format); + /*<>*/ invalid_format_message + (end_ind, cst_unexpected_end_of_format); + /*<>*/ return; /*<>*/ } function invalid_format_without(str_ind, c, s){ /*<>*/ return /*<>*/ caml_call4 @@ -18876,9 +18921,9 @@ b: try{ var - _bg_ = str_ind$3 === end_ind ? 1 : 0, - _bh_ = - _bg_ + _bh_ = str_ind$3 === end_ind ? 1 : 0, + _bi_ = + _bh_ || (60 !== @@ -18886,7 +18931,7 @@ (str, str_ind$3) ? 1 : 0); - if(_bh_) + if(_bi_) /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace (Stdlib[8], 1); /*<>*/ var @@ -18925,12 +18970,12 @@ str, str_ind$3 - 2 | 0, (str_ind_3 - str_ind$3 | 0) + 3 | 0), - /*<>*/ _bi_ = - [0, s, width, 0], /*<>*/ _bj_ = + [0, s, width, 0], + /*<>*/ _bk_ = str_ind_3 + 1 | 0, - formatting_lit$0 = _bi_, - next_ind = _bj_; + formatting_lit$0 = _bj_, + next_ind = _bk_; break b; } } @@ -18956,21 +19001,21 @@ str, str_ind$3 - 2 | 0, (str_ind_5 - str_ind$3 | 0) + 3 | 0), - /*<>*/ _bk_ = - [0, s$0, width, offset], /*<>*/ _bl_ = + [0, s$0, width, offset], + /*<>*/ _bm_ = str_ind_5 + 1 | 0, - formatting_lit$0 = _bk_, - next_ind = _bl_; + formatting_lit$0 = _bl_, + next_ind = _bm_; break b; } /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace (Stdlib[8], 1); } - catch(_bq_){ - var _bf_ = caml_wrap_exception(_bq_); - if(_bf_ !== Stdlib[8] && _bf_[1] !== Stdlib[7]) - throw caml_maybe_attach_backtrace(_bf_, 0); + catch(_br_){ + var _bg_ = caml_wrap_exception(_br_); + if(_bg_ !== Stdlib[8] && _bg_[1] !== Stdlib[7]) + throw caml_maybe_attach_backtrace(_bg_, 0); var formatting_lit$0 = formatting_lit, next_ind = str_ind$3; } var @@ -18994,7 +19039,7 @@ if(58 > match$6) break c; } else if(45 === match$6) break c; - var _bo_ = 0; + var _bp_ = 0; break b; } /*<>*/ var @@ -19018,28 +19063,28 @@ str, str_ind$4 - 2 | 0, (str_ind_3$0 - str_ind$4 | 0) + 3 | 0), - _bo_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]]; + _bp_ = [0, [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]]; } - var _bn_ = _bo_; + var _bo_ = _bp_; } - catch(_bp_){ - var _bm_ = caml_wrap_exception(_bp_); - if(_bm_ !== Stdlib[8] && _bm_[1] !== Stdlib[7]) - throw caml_maybe_attach_backtrace(_bm_, 0); - var _bn_ = 0; + catch(_bq_){ + var _bn_ = caml_wrap_exception(_bq_); + if(_bn_ !== Stdlib[8] && _bn_[1] !== Stdlib[7]) + throw caml_maybe_attach_backtrace(_bn_, 0); + var _bo_ = 0; } - if(_bn_) + if(_bo_) var - match$5 = _bn_[1], + match$5 = _bo_[1], formatting_lit$1 = match$5[2], next_ind$0 = match$5[1], fmt_rest$13 = parse(next_ind$0, end_ind)[1], - _be_ = [0, [17, formatting_lit$1, fmt_rest$13]]; + _bf_ = [0, [17, formatting_lit$1, fmt_rest$13]]; else var fmt_rest$14 = parse(str_ind$4, end_ind)[1], - _be_ = [0, [17, _Q_, fmt_rest$14]]; - var match$0 = _be_; + _bf_ = [0, [17, _Q_, fmt_rest$14]]; + var match$0 = _bf_; break a; case 31: var @@ -19197,29 +19242,29 @@ /*<>*/ var /*<>*/ ignored$2 = [9, get_pad_opt(95), sub_fmtty], - _aN_ = [0, [23, ignored$2, fmt_rest$7]]; + _aO_ = [0, [23, ignored$2, fmt_rest$7]]; else - var _aN_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]]; - var fmt_result = _aN_; + var _aO_ = [0, [14, get_pad_opt(40), sub_fmtty, fmt_rest$7]]; + var fmt_result = _aO_; break a; case 44: var fmt_result = parse(str_ind, end_ind); break a; case 67: /*<>*/ var fmt_rest$10 = parse(str_ind, end_ind)[1], - /*<>*/ _aP_ = + /*<>*/ _aQ_ = get_ign(0) ? [0, [23, 1, fmt_rest$10]] : [0, [1, fmt_rest$10]], - fmt_result = _aP_; + fmt_result = _aQ_; break a; case 78: var fmt_rest$14 = parse(str_ind, end_ind)[1], counter$0 = 2; /*<>*/ if(get_ign(0)) /*<>*/ var /*<>*/ ignored$6 = [11, counter$0], - _aV_ = [0, [23, ignored$6, fmt_rest$14]]; + _aW_ = [0, [23, ignored$6, fmt_rest$14]]; else - var _aV_ = [0, [21, counter$0, fmt_rest$14]]; - var fmt_result = _aV_; + var _aW_ = [0, [21, counter$0, fmt_rest$14]]; + var fmt_result = _aW_; break a; case 83: /*<>*/ var @@ -19230,15 +19275,15 @@ /*<>*/ var /*<>*/ ignored$7 = [1, get_padprec_opt(95)], - _aW_ = [0, [23, ignored$7, fmt_rest$15]]; + _aX_ = [0, [23, ignored$7, fmt_rest$15]]; else /*<>*/ var /*<>*/ match$5 = make_padding_fmt_ebb(pad$6, fmt_rest$15), fmt_rest$16 = match$5[2], pad$7 = match$5[1], - _aW_ = [0, [3, pad$7, fmt_rest$16]]; - var fmt_result = _aW_; + _aX_ = [0, [3, pad$7, fmt_rest$16]]; + var fmt_result = _aX_; break a; case 91: if(str_ind === end_ind) @@ -19249,8 +19294,9 @@ create_char_set(0), add_char = function(c){ - /*<>*/ return add_in_char_set - (char_set, c); + /*<>*/ add_in_char_set + (char_set, c); + /*<>*/ return; /*<>*/ }, add_range = function(c$0, c){ @@ -19262,12 +19308,12 @@ /*<>*/ caml_call1 (Stdlib[29], i)); /*<>*/ /*<>*/ var - _bd_ = i + 1 | 0; + _be_ = i + 1 | 0; if(c === i) break; - var i = _bd_; + var i = _be_; } } - return 0; + return; /*<>*/ }, fail_single_percent = function(str_ind){ @@ -19289,13 +19335,13 @@ if(93 === c) /*<>*/ return str_ind$0 + 1 | 0; - var _bc_ = str_ind$0 + 1 | 0; + var _bd_ = str_ind$0 + 1 | 0; /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return - (parse_char_set_after_char$0, [0, _bc_, end_ind, c]); + (parse_char_set_after_char$0, [0, _bd_, end_ind, c]); var counter$0 = counter + 1 | 0; /*<>*/ return parse_char_set_after_char$0 - (counter$0, _bc_, end_ind, c); + (counter$0, _bd_, end_ind, c); } /*<>*/ add_char(45); var str_ind$1 = str_ind$0 + 1 | 0, str_ind$0 = str_ind$1; @@ -19346,13 +19392,13 @@ /*<>*/ return fail_single_percent (str_ind$2); /*<>*/ add_range(c$0, c$3); - var _ba_ = str_ind$2 + 2 | 0; + var _bb_ = str_ind$2 + 2 | 0; /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return - (parse_char_set_content, [0, _ba_, end_ind]); + (parse_char_set_content, [0, _bb_, end_ind]); var counter$2 = counter + 1 | 0; /*<>*/ return parse_char_set_content - (counter$2, _ba_, end_ind); + (counter$2, _bb_, end_ind); } if(93 === c$2){ /*<>*/ add_char(c$0); @@ -19361,23 +19407,23 @@ | 0; } /*<>*/ add_range(c$0, c$2); - var _bb_ = str_ind$2 + 1 | 0; + var _bc_ = str_ind$2 + 1 | 0; /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return - (parse_char_set_content, [0, _bb_, end_ind]); + (parse_char_set_content, [0, _bc_, end_ind]); var counter$1 = counter + 1 | 0; /*<>*/ return parse_char_set_content - (counter$1, _bb_, end_ind); + (counter$1, _bc_, end_ind); } if(37 === c$0){ /*<>*/ add_char(c$1); - var _a$_ = str_ind$0 + 1 | 0; + var _ba_ = str_ind$0 + 1 | 0; /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return - (parse_char_set_content, [0, _a$_, end_ind]); + (parse_char_set_content, [0, _ba_, end_ind]); var counter$0 = counter + 1 | 0; /*<>*/ return parse_char_set_content - (counter$0, _a$_, end_ind); + (counter$0, _ba_, end_ind); } } if(37 === c$0) @@ -19427,10 +19473,10 @@ /*<>*/ var /*<>*/ ignored$9 = [10, get_pad_opt(95), char_set$1], - _a1_ = [0, [23, ignored$9, fmt_rest$19]]; + _a2_ = [0, [23, ignored$9, fmt_rest$19]]; else - var _a1_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]]; - var fmt_result = _a1_; + var _a2_ = [0, [20, get_pad_opt(91), char_set$1, fmt_rest$19]]; + var fmt_result = _a2_; break a; case 97: var @@ -19450,28 +19496,28 @@ if(match$7){ if(0 === match$7[1]) /*<>*/ var - /*<>*/ _a2_ = + /*<>*/ _a3_ = get_ign(0) ? [0, [23, 3, fmt_rest$21]] : [0, [22, fmt_rest$21]], - _a3_ = _a2_; + _a4_ = _a3_; else var - _a3_ = + _a4_ = legacy_behavior$0 ? char_format(fmt_rest$21) : invalid_format_message (str_ind, cst_non_zero_widths_are_unsupp); - var _a4_ = _a3_; + var _a5_ = _a4_; } else - var _a4_ = char_format(fmt_rest$21); - var fmt_result = _a4_; + var _a5_ = char_format(fmt_rest$21); + var fmt_result = _a5_; break a; case 114: /*<>*/ var fmt_rest$22 = parse(str_ind, end_ind)[1], - /*<>*/ _a5_ = + /*<>*/ _a6_ = get_ign(0) ? [0, [23, 2, fmt_rest$22]] : [0, [19, fmt_rest$22]], - fmt_result = _a5_; + fmt_result = _a6_; break a; case 115: /*<>*/ var @@ -19482,15 +19528,15 @@ /*<>*/ var /*<>*/ ignored$10 = [0, get_padprec_opt(95)], - _a6_ = [0, [23, ignored$10, fmt_rest$23]]; + _a7_ = [0, [23, ignored$10, fmt_rest$23]]; else /*<>*/ var /*<>*/ match$8 = make_padding_fmt_ebb(pad$9, fmt_rest$23), fmt_rest$24 = match$8[2], pad$10 = match$8[1], - _a6_ = [0, [2, pad$10, fmt_rest$24]]; - var fmt_result = _a6_; + _a7_ = [0, [2, pad$10, fmt_rest$24]]; + var fmt_result = _a7_; break a; case 116: var @@ -19509,10 +19555,10 @@ /*<>*/ var /*<>*/ ignored$11 = [8, get_pad_opt(95), sub_fmtty$0], - _a7_ = [0, [23, ignored$11, fmt_rest$26]]; + _a8_ = [0, [23, ignored$11, fmt_rest$26]]; else - var _a7_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]]; - var fmt_result = _a7_; + var _a8_ = [0, [13, get_pad_opt(123), sub_fmtty$0, fmt_rest$26]]; + var fmt_result = _a8_; break a; case 66: case 98: @@ -19524,15 +19570,15 @@ /*<>*/ var /*<>*/ ignored$3 = [7, get_padprec_opt(95)], - _aO_ = [0, [23, ignored$3, fmt_rest$8]]; + _aP_ = [0, [23, ignored$3, fmt_rest$8]]; else /*<>*/ var /*<>*/ match$3 = make_padding_fmt_ebb(pad$3, fmt_rest$8), fmt_rest$9 = match$3[2], pad$4 = match$3[1], - _aO_ = [0, [9, pad$4, fmt_rest$9]]; - var fmt_result = _aO_; + _aP_ = [0, [9, pad$4, fmt_rest$9]]; + var fmt_result = _aP_; break a; case 37: case 64: @@ -19548,22 +19594,22 @@ /*<>*/ symb$0 = /*<>*/ caml_string_get (str, str_ind), - /*<>*/ _a8_ = symb$0 - 88 | 0; + /*<>*/ _a9_ = symb$0 - 88 | 0; b: { - if(32 >= _a8_ >>> 0) - switch(_a8_){ + if(32 >= _a9_ >>> 0) + switch(_a9_){ case 0: case 12: case 17: case 23: case 29: case 32: - var _aU_ = 1; break b; + var _aV_ = 1; break b; } - var _aU_ = 0; + var _aV_ = 0; } - /*<>*/ if(_aU_) break; + /*<>*/ if(_aV_) break; } var fmt_rest$13 = parse(str_ind, end_ind)[1]; b: @@ -19584,10 +19630,10 @@ /*<>*/ if(get_ign(0)) /*<>*/ var /*<>*/ ignored$5 = [11, counter], - _aT_ = [0, [23, ignored$5, fmt_rest$13]]; + _aU_ = [0, [23, ignored$5, fmt_rest$13]]; else - var _aT_ = [0, [21, counter, fmt_rest$13]]; - var fmt_result = _aT_; + var _aU_ = [0, [21, counter, fmt_rest$13]]; + var fmt_result = _aU_; break a; case 32: case 35: @@ -19606,26 +19652,26 @@ case 117: case 120: /*<>*/ var - /*<>*/ _aX_ = get_space(0), - /*<>*/ _aY_ = get_hash(0), + /*<>*/ _aY_ = get_space(0), + /*<>*/ _aZ_ = get_hash(0), /*<>*/ iconv$2 = - compute_int_conv(pct_ind, str_ind, get_plus(0), _aY_, _aX_, symb), + compute_int_conv(pct_ind, str_ind, get_plus(0), _aZ_, _aY_, symb), fmt_rest$17 = parse(str_ind, end_ind)[1]; /*<>*/ if(get_ign(0)) /*<>*/ var /*<>*/ ignored$8 = [2, iconv$2, get_pad_opt(95)], - _aZ_ = [0, [23, ignored$8, fmt_rest$17]]; + _a0_ = [0, [23, ignored$8, fmt_rest$17]]; else /*<>*/ var - /*<>*/ _a0_ = get_prec(0), + /*<>*/ _a1_ = get_prec(0), /*<>*/ match$6 = - make_padprec_fmt_ebb(get_int_pad(0), _a0_, fmt_rest$17), + make_padprec_fmt_ebb(get_int_pad(0), _a1_, fmt_rest$17), fmt_rest$18 = match$6[3], prec$4 = match$6[2], pad$8 = match$6[1], - _aZ_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]]; - var fmt_result = _aZ_; + _a0_ = [0, [4, iconv$2, pad$8, prec$4, fmt_rest$18]]; + var fmt_result = _a0_; break a; case 69: case 70: @@ -19655,28 +19701,28 @@ if(3 >= switcher >>> 0){ switch(switcher){ case 0: - var _a9_ = 1; break; + var _a__ = 1; break; case 1: - var _a9_ = 0; break; + var _a__ = 0; break; case 2: - var _a9_ = 3; break; - default: var _a9_ = 6; + var _a__ = 3; break; + default: var _a__ = 6; } - var kind = _a9_; + var kind = _a__; break b; } } else if(69 <= symb){ switch(symb - 69 | 0){ case 0: - var _a__ = 2; break; + var _a$_ = 2; break; case 1: break c; case 2: - var _a__ = 4; break; - default: var _a__ = 7; + var _a$_ = 4; break; + default: var _a$_ = 7; } - var kind = _a__; + var kind = _a$_; break b; } if(hash$1){ @@ -19694,25 +19740,25 @@ match = get_prec(0); if(typeof match === "number") var - _aQ_ = + _aR_ = match ? incompatible_flag(pct_ind, str_ind, 95, cst$26) : 0; else - var ndec = match[1], _aQ_ = [0, ndec]; + var ndec = match[1], _aR_ = [0, ndec]; /*<>*/ var /*<>*/ ignored$4 = - [6, get_pad_opt(95), _aQ_], - _aR_ = [0, [23, ignored$4, fmt_rest$11]]; + [6, get_pad_opt(95), _aR_], + _aS_ = [0, [23, ignored$4, fmt_rest$11]]; } else /*<>*/ var - /*<>*/ _aS_ = get_prec(0), + /*<>*/ _aT_ = get_prec(0), /*<>*/ match$4 = - make_padprec_fmt_ebb(get_pad(0), _aS_, fmt_rest$11), + make_padprec_fmt_ebb(get_pad(0), _aT_, fmt_rest$11), fmt_rest$12 = match$4[3], prec$3 = match$4[2], pad$5 = match$4[1], - _aR_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]]; - var fmt_result = _aR_; + _aS_ = [0, [8, fconv, pad$5, prec$3, fmt_rest$12]]; + var fmt_result = _aS_; break a; } b: @@ -19721,89 +19767,89 @@ switch(symb - 108 | 0){ case 0: /*<>*/ var - /*<>*/ _ax_ = + /*<>*/ _ay_ = /*<>*/ caml_string_get (str, str_ind), - /*<>*/ _ay_ = get_space(0), - /*<>*/ _az_ = get_hash(0), + /*<>*/ _az_ = get_space(0), + /*<>*/ _aA_ = get_hash(0), /*<>*/ iconv = compute_int_conv - (pct_ind, str_ind + 1 | 0, get_plus(0), _az_, _ay_, _ax_), + (pct_ind, str_ind + 1 | 0, get_plus(0), _aA_, _az_, _ay_), fmt_rest = parse(str_ind + 1 | 0, end_ind)[1]; /*<>*/ if(get_ign(0)) /*<>*/ var /*<>*/ ignored = [3, iconv, get_pad_opt(95)], - _aA_ = [0, [23, ignored, fmt_rest]]; + _aB_ = [0, [23, ignored, fmt_rest]]; else /*<>*/ var - /*<>*/ _aC_ = get_prec(0), + /*<>*/ _aD_ = get_prec(0), /*<>*/ match$0 = - make_padprec_fmt_ebb(get_int_pad(0), _aC_, fmt_rest), + make_padprec_fmt_ebb(get_int_pad(0), _aD_, fmt_rest), fmt_rest$0 = match$0[3], prec$0 = match$0[2], pad$0 = match$0[1], - _aA_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]]; - var _aB_ = _aA_; + _aB_ = [0, [5, iconv, pad$0, prec$0, fmt_rest$0]]; + var _aC_ = _aB_; break; case 1: break b; default: /*<>*/ var - /*<>*/ _aD_ = + /*<>*/ _aE_ = /*<>*/ caml_string_get (str, str_ind), - /*<>*/ _aE_ = get_space(0), - /*<>*/ _aF_ = get_hash(0), + /*<>*/ _aF_ = get_space(0), + /*<>*/ _aG_ = get_hash(0), /*<>*/ iconv$0 = compute_int_conv - (pct_ind, str_ind + 1 | 0, get_plus(0), _aF_, _aE_, _aD_), + (pct_ind, str_ind + 1 | 0, get_plus(0), _aG_, _aF_, _aE_), fmt_rest$1 = parse(str_ind + 1 | 0, end_ind)[1]; /*<>*/ if(get_ign(0)) /*<>*/ var /*<>*/ ignored$0 = [4, iconv$0, get_pad_opt(95)], - _aG_ = [0, [23, ignored$0, fmt_rest$1]]; + _aH_ = [0, [23, ignored$0, fmt_rest$1]]; else /*<>*/ var - /*<>*/ _aH_ = get_prec(0), + /*<>*/ _aI_ = get_prec(0), /*<>*/ match$1 = - make_padprec_fmt_ebb(get_int_pad(0), _aH_, fmt_rest$1), + make_padprec_fmt_ebb(get_int_pad(0), _aI_, fmt_rest$1), fmt_rest$2 = match$1[3], prec$1 = match$1[2], pad$1 = match$1[1], - _aG_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]]; - var _aB_ = _aG_; + _aH_ = [0, [6, iconv$0, pad$1, prec$1, fmt_rest$2]]; + var _aC_ = _aH_; } - var fmt_result = _aB_; + var fmt_result = _aC_; break a; } } else if(76 === symb){ /*<>*/ var - /*<>*/ _aI_ = + /*<>*/ _aJ_ = /*<>*/ caml_string_get(str, str_ind), - /*<>*/ _aJ_ = get_space(0), - /*<>*/ _aK_ = get_hash(0), + /*<>*/ _aK_ = get_space(0), + /*<>*/ _aL_ = get_hash(0), /*<>*/ iconv$1 = compute_int_conv - (pct_ind, str_ind + 1 | 0, get_plus(0), _aK_, _aJ_, _aI_), + (pct_ind, str_ind + 1 | 0, get_plus(0), _aL_, _aK_, _aJ_), fmt_rest$3 = parse(str_ind + 1 | 0, end_ind)[1]; /*<>*/ if(get_ign(0)) /*<>*/ var /*<>*/ ignored$1 = [5, iconv$1, get_pad_opt(95)], - _aL_ = [0, [23, ignored$1, fmt_rest$3]]; + _aM_ = [0, [23, ignored$1, fmt_rest$3]]; else /*<>*/ var - /*<>*/ _aM_ = get_prec(0), + /*<>*/ _aN_ = get_prec(0), /*<>*/ match$2 = - make_padprec_fmt_ebb(get_int_pad(0), _aM_, fmt_rest$3), + make_padprec_fmt_ebb(get_int_pad(0), _aN_, fmt_rest$3), fmt_rest$4 = match$2[3], prec$2 = match$2[2], pad$2 = match$2[1], - _aL_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]]; - var fmt_result = _aL_; + _aM_ = [0, [7, iconv$1, pad$2, prec$2, fmt_rest$4]]; + var fmt_result = _aM_; break a; } var @@ -19812,46 +19858,46 @@ (failwith_message(_J_), str, str_ind - 1 | 0, symb); } if(1 - legacy_behavior$0){ - var _ao_ = 1 - plus_used[1], plus$0 = _ao_ ? plus : _ao_; + var _ap_ = 1 - plus_used[1], plus$0 = _ap_ ? plus : _ap_; if(plus$0) /*<>*/ incompatible_flag (pct_ind, str_ind, symb, cst$27); - var _ap_ = 1 - hash_used[1], hash$0 = _ap_ ? hash : _ap_; + var _aq_ = 1 - hash_used[1], hash$0 = _aq_ ? hash : _aq_; if(hash$0) /*<>*/ incompatible_flag (pct_ind, str_ind, symb, cst$28); - var _aq_ = 1 - space_used[1], space$0 = _aq_ ? space : _aq_; + var _ar_ = 1 - space_used[1], space$0 = _ar_ ? space : _ar_; if(space$0) /*<>*/ incompatible_flag (pct_ind, str_ind, symb, cst$29); var - _ar_ = 1 - pad_used[1], - _as_ = - _ar_ + _as_ = 1 - pad_used[1], + _at_ = + _as_ ? /*<>*/ caml_notequal ([0, pad], _K_) - : _ar_; - /*<>*/ if(_as_) + : _as_; + /*<>*/ if(_at_) /*<>*/ incompatible_flag (pct_ind, str_ind, symb, cst_padding$0); var - _at_ = 1 - prec_used[1], - _au_ = - _at_ + _au_ = 1 - prec_used[1], + _av_ = + _au_ ? /*<>*/ caml_notequal ([0, prec], _L_) - : _at_; - /*<>*/ if(_au_){ - var _av_ = ign ? 95 : symb; + : _au_; + /*<>*/ if(_av_){ + var _aw_ = ign ? 95 : symb; /*<>*/ incompatible_flag - (pct_ind, str_ind, _av_, cst_precision$2); + (pct_ind, str_ind, _aw_, cst_precision$2); } var plus$1 = ign ? plus : ign; if(plus$1) /*<>*/ incompatible_flag (pct_ind, str_ind, 95, cst$30); } - var _aw_ = 1 - ign_used[1], ign$0 = _aw_ ? ign : _aw_; + var _ax_ = 1 - ign_used[1], ign$0 = _ax_ ? ign : _ax_; a: if(ign$0){ b: @@ -19968,10 +20014,10 @@ case 3: if(legacy_behavior$0){ /*<>*/ var - /*<>*/ _an_ = str_ind$0 + 1 | 0, + /*<>*/ _ao_ = str_ind$0 + 1 | 0, minus$0 = minus || (45 === symb$0 ? 1 : 0); /*<>*/ return parse_literal - (minus$0, _an_); + (minus$0, _ao_); } break; } @@ -19998,17 +20044,17 @@ /*<>*/ hash = [0, 0]; function set_flag(str_ind, flag){ /*<>*/ var - _ak_ = flag[1], - _al_ = _ak_ ? 1 - legacy_behavior$0 : _ak_; - if(_al_){ + _al_ = flag[1], + _am_ = _al_ ? 1 - legacy_behavior$0 : _al_; + if(_am_){ /*<>*/ /*<>*/ var - _am_ = + _an_ = /*<>*/ caml_string_get(str, str_ind); /*<>*/ /*<>*/ caml_call3 - (failwith_message(_C_), str, str_ind, _am_); + (failwith_message(_C_), str, str_ind, _an_); } flag[1] = 1; - return 0; + return; /*<>*/ } var str_ind$0 = str_ind; /*<>*/ for(;;){ @@ -20178,13 +20224,13 @@ [0, sub_fmt, sub_str], /*<>*/ formatting$0 = is_open_tag ? [0, sub_format$0] : [1, sub_format$0], - /*<>*/ _ai_ = + /*<>*/ _aj_ = [0, [18, formatting$0, fmt_rest$0]]; - /*<>*/ return _ai_; + /*<>*/ return _aj_; } - catch(_aj_){ - var _ah_ = caml_wrap_exception(_aj_); - if(_ah_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ah_, 0); + catch(_ak_){ + var _ai_ = caml_wrap_exception(_ak_); + if(_ai_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ai_, 0); /*<>*/ var fmt_rest = parse(str_ind, end_ind)[1], /*<>*/ formatting = @@ -20224,9 +20270,9 @@ var new_acc = (acc$0 * 10 | 0) + (c - 48 | 0) | 0; if(Stdlib_Sys[12] < new_acc){ /*<>*/ /*<>*/ var - _ag_ = Stdlib_Sys[12]; + _ah_ = Stdlib_Sys[12]; /*<>*/ return /*<>*/ caml_call3 - (failwith_message(_S_), str, new_acc, _ag_); + (failwith_message(_S_), str, new_acc, _ah_); } var str_ind$1 = str_ind$0 + 1 | 0, @@ -20480,16 +20526,16 @@ fmt = fmt_ebb_of_string(0, str)[1]; /*<>*/ try{ /*<>*/ /*<>*/ var - _ae_ = [0, type_format(fmt, fmtty), str]; - /*<>*/ return _ae_; + _af_ = [0, type_format(fmt, fmtty), str]; + /*<>*/ return _af_; } - catch(_af_){ - var _ac_ = caml_wrap_exception(_af_); - if(_ac_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ac_, 0); + catch(_ag_){ + var _ad_ = caml_wrap_exception(_ag_); + if(_ad_ !== Type_mismatch) throw caml_maybe_attach_backtrace(_ad_, 0); /*<>*/ /*<>*/ var - _ad_ = string_of_fmtty(fmtty); + _ae_ = string_of_fmtty(fmtty); /*<>*/ return /*<>*/ caml_call2 - (failwith_message(_Z_), str, _ad_); + (failwith_message(_Z_), str, _ae_); } /*<>*/ } function format_of_string_format(str, param){ @@ -20499,15 +20545,15 @@ fmt$0 = fmt_ebb_of_string(0, str)[1]; /*<>*/ try{ /*<>*/ /*<>*/ var - _aa_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str]; - /*<>*/ return _aa_; + _ab_ = [0, type_format(fmt$0, fmtty_of_fmt(fmt)), str]; + /*<>*/ return _ab_; } - catch(_ab_){ - var _$_ = caml_wrap_exception(_ab_); - if(_$_ === Type_mismatch) + catch(_ac_){ + var _aa_ = caml_wrap_exception(_ac_); + if(_aa_ === Type_mismatch) /*<>*/ return /*<>*/ caml_call2 (failwith_message(___), str, str$0); - throw caml_maybe_attach_backtrace(_$_, 0); + throw caml_maybe_attach_backtrace(_aa_, 0); } } var @@ -20715,6 +20761,7 @@ : runtime.caml_call_gen(f, [a0, a1, a2, a3, a4, a5]); } /*<>*/ var + _y_ = undefined, global_data = runtime.caml_get_global_data(), cst$7 = "\n", cst$4 = cst$8, @@ -20807,18 +20854,18 @@ /*<>*/ var t = l[2], h = l[1], - /*<>*/ _aD_ = + /*<>*/ _aE_ = /*<>*/ caml_call2(Stdlib[28], prefix, h); - function _aE_(x, y){ + function _aF_(x, y){ /*<>*/ /*<>*/ var - _aG_ = /*<>*/ caml_call2(Stdlib[28], sep, y); + _aH_ = /*<>*/ caml_call2(Stdlib[28], sep, y); /*<>*/ return /*<>*/ caml_call2 - (Stdlib[28], x, _aG_); + (Stdlib[28], x, _aH_); /*<>*/ } /*<>*/ /*<>*/ var - _aF_ = /*<>*/ caml_call3(Stdlib_List[26], _aE_, _aD_, t); + _aG_ = /*<>*/ caml_call3(Stdlib_List[26], _aF_, _aE_, t); /*<>*/ return /*<>*/ caml_call2 - (Stdlib[28], _aF_, suffix); + (Stdlib[28], _aG_, suffix); /*<>*/ } function help_action(param){ /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace @@ -20827,11 +20874,11 @@ function add_help(speclist){ /*<>*/ try{ /*<>*/ assoc3(cst_help$2, speclist); - /*<>*/ var /*<>*/ _aA_ = 0, add1 = _aA_; + /*<>*/ var /*<>*/ _aB_ = 0, add1 = _aB_; } - catch(_aC_){ - var _aw_ = caml_wrap_exception(_aC_); - if(_aw_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_aw_, 0); + catch(_aD_){ + var _ax_ = caml_wrap_exception(_aD_); + if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0); var add1 = [0, @@ -20840,11 +20887,11 @@ } try{ /*<>*/ assoc3(cst_help$1, speclist); - /*<>*/ var /*<>*/ _az_ = 0, add2 = _az_; + /*<>*/ var /*<>*/ _aA_ = 0, add2 = _aA_; } - catch(_aB_){ - var _ax_ = caml_wrap_exception(_aB_); - if(_ax_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ax_, 0); + catch(_aC_){ + var _ay_ = caml_wrap_exception(_aC_); + if(_ay_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ay_, 0); var add2 = [0, @@ -20852,33 +20899,34 @@ 0]; } /*<>*/ /*<>*/ var - _ay_ = /*<>*/ caml_call2(Stdlib[37], add1, add2); + _az_ = /*<>*/ caml_call2(Stdlib[37], add1, add2); /*<>*/ return /*<>*/ caml_call2 - (Stdlib[37], speclist, _ay_); + (Stdlib[37], speclist, _az_); /*<>*/ } function usage_b(buf, speclist, errmsg){ /*<>*/ /*<>*/ caml_call3 (Stdlib_Printf[5], buf, _d_, errmsg); /*<>*/ /*<>*/ var - _as_ = add_help(speclist); - /*<>*/ function _at_(param){ + _at_ = add_help(speclist); + /*<>*/ function _au_(param){ var doc = param[3], spec = param[2], key = param[1], - _au_ = 0 < /*<>*/ caml_ml_string_length(doc) ? 1 : 0; - if(! _au_) return _au_; + _av_ = 0 < /*<>*/ caml_ml_string_length(doc) ? 1 : 0; + if(! _av_) return _av_; if(11 !== spec[0]) /*<>*/ return /*<>*/ caml_call4 (Stdlib_Printf[5], buf, _a_, key, doc); /*<>*/ var l = spec[1], - /*<>*/ _av_ = make_symlist(cst$1, cst$0, cst, l); + /*<>*/ _aw_ = make_symlist(cst$1, cst$0, cst, l); /*<>*/ return /*<>*/ caml_call5 - (Stdlib_Printf[5], buf, _b_, key, _av_, doc); + (Stdlib_Printf[5], buf, _b_, key, _aw_, doc); } - /*<>*/ return /*<>*/ caml_call2 - (Stdlib_List[18], _at_, _as_); + /*<>*/ /*<>*/ caml_call2 + (Stdlib_List[18], _au_, _at_); + /*<>*/ return; /*<>*/ } function usage_string(speclist, errmsg){ /*<>*/ /*<>*/ var @@ -20889,33 +20937,33 @@ /*<>*/ } function usage(speclist, errmsg){ /*<>*/ /*<>*/ var - _ar_ = usage_string(speclist, errmsg); + _as_ = usage_string(speclist, errmsg); /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Printf[3], _e_, _ar_); + (Stdlib_Printf[3], _e_, _as_); /*<>*/ } /*<>*/ /*<>*/ var current = [0, 0]; function int_of_string_opt(x){ /*<>*/ try{ /*<>*/ /*<>*/ var - _ap_ = [0, /*<>*/ runtime.caml_int_of_string(x)]; - /*<>*/ return _ap_; + _aq_ = [0, /*<>*/ runtime.caml_int_of_string(x)]; + /*<>*/ return _aq_; } - catch(_aq_){ - var _ao_ = caml_wrap_exception(_aq_); - if(_ao_[1] === Stdlib[7]) /*<>*/ return 0; - throw caml_maybe_attach_backtrace(_ao_, 0); + catch(_ar_){ + var _ap_ = caml_wrap_exception(_ar_); + if(_ap_[1] === Stdlib[7]) /*<>*/ return 0; + throw caml_maybe_attach_backtrace(_ap_, 0); } /*<>*/ } function float_of_string_opt(x){ /*<>*/ try{ /*<>*/ /*<>*/ var - _am_ = [0, /*<>*/ runtime.caml_float_of_string(x)]; - /*<>*/ return _am_; + _an_ = [0, /*<>*/ runtime.caml_float_of_string(x)]; + /*<>*/ return _an_; } - catch(_an_){ - var _al_ = caml_wrap_exception(_an_); - if(_al_[1] === Stdlib[7]) /*<>*/ return 0; - throw caml_maybe_attach_backtrace(_al_, 0); + catch(_ao_){ + var _am_ = caml_wrap_exception(_ao_); + if(_am_[1] === Stdlib[7]) /*<>*/ return 0; + throw caml_maybe_attach_backtrace(_am_, 0); } /*<>*/ } function parse_and_expand_argv_dynamic_ @@ -20970,20 +21018,20 @@ if(current[1] >= argv[1].length - 1) return 0; /*<>*/ try{ /*<>*/ var - _Y_ = current[1], - /*<>*/ s = caml_check_bound(argv[1], _Y_)[1 + _Y_]; + _Z_ = current[1], + /*<>*/ s = caml_check_bound(argv[1], _Z_)[1 + _Z_]; /*<>*/ if ( /*<>*/ caml_call2(Stdlib_String[11], cst$3, s)){ try{ /*<>*/ var follow$1 = 0, - /*<>*/ _aa_ = assoc3(s, speclist[1]), + /*<>*/ _ab_ = assoc3(s, speclist[1]), follow$0 = follow$1, - action = _aa_; + action = _ab_; } - catch(_aj_){ - var _Z_ = caml_wrap_exception(_aj_); - if(_Z_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_Z_, 0); + catch(_ak_){ + var ___ = caml_wrap_exception(_ak_); + if(___ !== Stdlib[8]) throw caml_maybe_attach_backtrace(___, 0); /*<>*/ try{ /*<>*/ var /*<>*/ i = @@ -20996,24 +21044,23 @@ /*<>*/ keyword = /*<>*/ caml_call3(Stdlib_String[16], s, 0, i), /*<>*/ follow = [0, arg], - /*<>*/ _$_ = assoc3(keyword, speclist[1]), + /*<>*/ _aa_ = assoc3(keyword, speclist[1]), follow$0 = follow, - action = _$_; + action = _aa_; } - catch(_ak_){ - var ___ = caml_wrap_exception(_ak_); - if(___ === Stdlib[8]) + catch(_al_){ + var _$_ = caml_wrap_exception(_al_); + if(_$_ === Stdlib[8]) /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace ([0, Stop, [0, s]], 1); - throw caml_maybe_attach_backtrace(___, 0); + throw caml_maybe_attach_backtrace(_$_, 0); } } var no_arg$0 = function(s, follow){ function no_arg(param){ - /*<>*/ if(! follow) - /*<>*/ return 0; + /*<>*/ if(! follow) /*<>*/ return; var arg = follow[1]; /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace ([0, Stop, [1, s, arg, cst_no_argument]], 1); @@ -21031,9 +21078,9 @@ if((current[1] + 1 | 0) >= argv[1].length - 1) /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace ([0, Stop, [2, s]], 1); - var _ai_ = current[1] + 1 | 0; - /*<>*/ return caml_check_bound(argv[1], _ai_) - [1 + _ai_]; + var _aj_ = current[1] + 1 | 0; + /*<>*/ return caml_check_bound(argv[1], _aj_) + [1 + _aj_]; /*<>*/ } return get_arg; }, @@ -21061,14 +21108,14 @@ /*<>*/ arg = get_arg(0); /*<>*/ try{ /*<>*/ var - /*<>*/ _ac_ = + /*<>*/ _ad_ = [0, /*<>*/ caml_call1(Stdlib[32], arg)], - match = _ac_; + match = _ad_; } - catch(_ah_){ - var _ab_ = caml_wrap_exception(_ah_); - if(_ab_[1] !== Stdlib[6]) - throw caml_maybe_attach_backtrace(_ab_, 0); + catch(_ai_){ + var _ac_ = caml_wrap_exception(_ai_); + if(_ac_[1] !== Stdlib[6]) + throw caml_maybe_attach_backtrace(_ac_, 0); var match = 0; } if(! match) @@ -21163,7 +21210,7 @@ /*<>*/ return consume_arg(0); } /*<>*/ /*<>*/ var - _ad_ = make_symlist(cst$6, cst$5, cst$4, symb); + _ae_ = make_symlist(cst$6, cst$5, cst$4, symb); /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace ([0, Stop, @@ -21171,16 +21218,16 @@ s, arg$5, /*<>*/ caml_call2 - (Stdlib[28], cst_one_of, _ad_)]], + (Stdlib[28], cst_one_of, _ae_)]], 1); case 12: var f$5 = param[1]; /*<>*/ no_arg(0); /*<>*/ for(;;){ if(current[1] >= (argv[1].length - 1 - 1 | 0)) return 0; - var _ae_ = current[1] + 1 | 0; + var _af_ = current[1] + 1 | 0; /*<>*/ /*<>*/ caml_call1 - (f$5, caml_check_bound(argv[1], _ae_)[1 + _ae_]); + (f$5, caml_check_bound(argv[1], _af_)[1 + _af_]); /*<>*/ consume_arg(0); } break; @@ -21193,8 +21240,8 @@ /*<>*/ return /*<>*/ caml_call1 (f$6, /*<>*/ caml_call1(Stdlib_List[10], acc[1])); - var _ag_ = current[1] + 1 | 0, _af_ = acc[1]; - acc[1] = [0, caml_check_bound(argv[1], _ag_)[1 + _ag_], _af_]; + var _ah_ = current[1] + 1 | 0, _ag_ = acc[1]; + acc[1] = [0, caml_check_bound(argv[1], _ah_)[1 + _ah_], _ag_]; /*<>*/ consume_arg(0); } break; @@ -21271,8 +21318,8 @@ function parse(l, f, msg){ /*<>*/ try{ /*<>*/ /*<>*/ var - _X_ = parse_argv(0, caml_sys_argv(0), l, f, msg); - /*<>*/ return _X_; + _Y_ = parse_argv(0, caml_sys_argv(0), l, f, msg); + /*<>*/ return _Y_; } catch(exn$0){ var exn = caml_wrap_exception(exn$0); @@ -21294,8 +21341,8 @@ function parse_dynamic(l, f, msg){ /*<>*/ try{ /*<>*/ /*<>*/ var - _W_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg); - /*<>*/ return _W_; + _X_ = parse_argv_dynamic(0, caml_sys_argv(0), l, f, msg); + /*<>*/ return _X_; } catch(exn$0){ var exn = caml_wrap_exception(exn$0); @@ -21320,9 +21367,9 @@ /*<>*/ argv = [0, caml_sys_argv(0)], /*<>*/ spec = [0, l], /*<>*/ current$0 = [0, current[1]], - /*<>*/ _V_ = + /*<>*/ _W_ = parse_and_expand_argv_dynamic(current$0, argv, spec, f, msg); - /*<>*/ return _V_; + /*<>*/ return _W_; } catch(exn$0){ var exn = caml_wrap_exception(exn$0); @@ -21359,17 +21406,17 @@ /*<>*/ /*<>*/ var n$0 = /*<>*/ caml_call2(Stdlib_String[36], s, 9); } - catch(_T_){ - var _R_ = caml_wrap_exception(_T_); - if(_R_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_R_, 0); + catch(_U_){ + var _S_ = caml_wrap_exception(_U_); + if(_S_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_S_, 0); /*<>*/ try{ /*<>*/ /*<>*/ var n = /*<>*/ caml_call2(Stdlib_String[36], s, 32); } - catch(_U_){ - var _S_ = caml_wrap_exception(_U_); - if(_S_ === Stdlib[8]) /*<>*/ return len; - throw caml_maybe_attach_backtrace(_S_, 0); + catch(_V_){ + var _T_ = caml_wrap_exception(_V_); + if(_T_ === Stdlib[8]) /*<>*/ return len; + throw caml_maybe_attach_backtrace(_T_, 0); } /*<>*/ return loop(n + 1 | 0); } @@ -21379,12 +21426,12 @@ var doc = param[3], spec = param[2], kwd = param[1]; /*<>*/ if(11 === spec[0]) return caml_call2(Stdlib_Int[11], cur, caml_ml_string_length(kwd)); - var _Q_ = caml_ml_string_length(kwd) + second_word(doc) | 0; - return caml_call2(Stdlib_Int[11], cur, _Q_); + var _R_ = caml_ml_string_length(kwd) + second_word(doc) | 0; + return caml_call2(Stdlib_Int[11], cur, _R_); } function replace_leading_tab(s){ /*<>*/ /*<>*/ var seen = [0, 0]; - function _P_(c){ + function _Q_(c){ /*<>*/ if(9 === c && ! seen[1]){ seen[1] = 1; /*<>*/ return 32; @@ -21392,7 +21439,7 @@ /*<>*/ return c; /*<>*/ } /*<>*/ return /*<>*/ caml_call2 - (Stdlib_String[18], _P_, s); + (Stdlib_String[18], _Q_, s); /*<>*/ } function align(opt, speclist){ /*<>*/ if(opt) @@ -21406,7 +21453,7 @@ (Stdlib_List[26], max_arg_len, 0, completed), /*<>*/ len$0 = /*<>*/ caml_call2(Stdlib_Int[10], len, limit); - /*<>*/ function _J_(ksd){ + /*<>*/ function _K_(ksd){ var kwd = ksd[1], spec = ksd[2]; if(! caml_string_notequal(ksd[3], cst$8)) /*<>*/ return ksd; @@ -21414,20 +21461,20 @@ /*<>*/ var msg$0 = ksd[3], /*<>*/ cutcol$0 = second_word(msg$0), - /*<>*/ _M_ = + /*<>*/ _N_ = /*<>*/ caml_call2 (Stdlib_Int[11], 0, len$0 - cutcol$0 | 0) + 3 | 0, /*<>*/ spaces$0 = - /*<>*/ caml_call2(Stdlib_String[1], _M_, 32), - /*<>*/ _N_ = replace_leading_tab(msg$0), - /*<>*/ _O_ = - /*<>*/ caml_call2(Stdlib[28], spaces$0, _N_); + /*<>*/ caml_call2(Stdlib_String[1], _N_, 32), + /*<>*/ _O_ = replace_leading_tab(msg$0), + /*<>*/ _P_ = + /*<>*/ caml_call2(Stdlib[28], spaces$0, _O_); /*<>*/ return [0, kwd, spec, - /*<>*/ caml_call2(Stdlib[28], cst$7, _O_)]; + /*<>*/ caml_call2(Stdlib[28], cst$7, _P_)]; } /*<>*/ var msg = ksd[3], @@ -21441,24 +21488,24 @@ /*<>*/ var /*<>*/ spaces = /*<>*/ caml_call2(Stdlib_String[1], diff, 32), - /*<>*/ _K_ = replace_leading_tab(msg), + /*<>*/ _L_ = replace_leading_tab(msg), /*<>*/ prefix = - /*<>*/ caml_call3(Stdlib_String[16], _K_, 0, cutcol), + /*<>*/ caml_call3(Stdlib_String[16], _L_, 0, cutcol), /*<>*/ suffix = /*<>*/ caml_call3 (Stdlib_String[16], msg, cutcol, caml_ml_string_length(msg) - cutcol | 0), - /*<>*/ _L_ = + /*<>*/ _M_ = /*<>*/ caml_call2(Stdlib[28], spaces, suffix); /*<>*/ return [0, kwd, spec$0, - /*<>*/ caml_call2(Stdlib[28], prefix, _L_)]; + /*<>*/ caml_call2(Stdlib[28], prefix, _M_)]; } /*<>*/ return /*<>*/ caml_call2 - (Stdlib_List[20], _J_, completed); + (Stdlib_List[20], _K_, completed); /*<>*/ } function read_aux(trim, sep, file){ /*<>*/ var @@ -21478,20 +21525,21 @@ (0 < len && 13 === /*<>*/ caml_string_get(word, len - 1 | 0)){ var - _I_ = + _J_ = /*<>*/ caml_call3 (Stdlib_String[16], word, 0, len - 1 | 0); break a; } - var _I_ = word; + var _J_ = word; } - var word$0 = _I_; + var word$0 = _J_; } else var word$0 = word; words[1] = [0, word$0, words[1]]; - /*<>*/ return /*<>*/ caml_call1 - (Stdlib_Buffer[8], buf); + /*<>*/ /*<>*/ caml_call1 + (Stdlib_Buffer[8], buf); + /*<>*/ return; /*<>*/ } /*<>*/ try{ for(;;){ @@ -21504,45 +21552,45 @@ (Stdlib_Buffer[12], buf, c); } } - catch(_H_){ - var _F_ = caml_wrap_exception(_H_); - if(_F_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_F_, 0); + catch(_I_){ + var _G_ = caml_wrap_exception(_I_); + if(_G_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_G_, 0); if(0 < /*<>*/ caml_call1(Stdlib_Buffer[7], buf)) /*<>*/ stash(0); /*<>*/ /*<>*/ caml_call1(Stdlib[93], ic); /*<>*/ /*<>*/ var - _G_ = /*<>*/ caml_call1(Stdlib_List[10], words[1]); + _H_ = /*<>*/ caml_call1(Stdlib_List[10], words[1]); /*<>*/ return /*<>*/ caml_call1 - (Stdlib_Array[10], _G_); + (Stdlib_Array[10], _H_); } /*<>*/ } var _r_ = 10, _s_ = 1; - /*<>*/ function read_arg(_E_){ - /*<>*/ return read_aux(_s_, _r_, _E_); + /*<>*/ function read_arg(_F_){ + /*<>*/ return read_aux(_s_, _r_, _F_); } /*<>*/ var /*<>*/ _t_ = 0, _u_ = 0; - /*<>*/ function read_arg0(_D_){ - /*<>*/ return read_aux(_u_, _t_, _D_); + /*<>*/ function read_arg0(_E_){ + /*<>*/ return read_aux(_u_, _t_, _E_); } function write_aux(sep, file, args){ /*<>*/ /*<>*/ var oc = /*<>*/ caml_call1(Stdlib[61], file); - function _C_(s){ + function _D_(s){ /*<>*/ return caml_call4 (Stdlib_Printf[1], oc, _v_, s, sep); /*<>*/ } /*<>*/ /*<>*/ caml_call2 - (Stdlib_Array[11], _C_, args); + (Stdlib_Array[11], _D_, args); /*<>*/ return /*<>*/ caml_call1 (Stdlib[76], oc); /*<>*/ } var _w_ = 10; - /*<>*/ function write_arg(_A_, _B_){ - /*<>*/ return write_aux(_w_, _A_, _B_); + /*<>*/ function write_arg(_B_, _C_){ + /*<>*/ return write_aux(_w_, _B_, _C_); } /*<>*/ /*<>*/ var _x_ = 0; - /*<>*/ function write_arg0(_y_, _z_){ - /*<>*/ return write_aux(_x_, _y_, _z_); + /*<>*/ function write_arg0(_z_, _A_){ + /*<>*/ return write_aux(_x_, _z_, _A_); } var Stdlib_Arg = @@ -22208,6 +22256,7 @@ global_data = runtime.caml_get_global_data(), Stdlib_Printexc = global_data.Stdlib__Printexc, Stdlib = global_data.Stdlib, + _b_ = undefined, cst_Fun_Finally_raised = "Fun.Finally_raised: ", cst_Stdlib_Fun_Finally_raised = "Stdlib.Fun.Finally_raised"; function const$0(c, param){ @@ -22238,9 +22287,8 @@ function protect(finally$0, work){ function finally_no_exn(param){ /*<>*/ try{ - /*<>*/ /*<>*/ var - _b_ = /*<>*/ caml_call1(finally$0, 0); - /*<>*/ return _b_; + /*<>*/ /*<>*/ caml_call1(finally$0, 0); + /*<>*/ return; } catch(e$0){ /*<>*/ var @@ -22700,6 +22748,7 @@ : runtime.caml_call_gen(f, [a0, a1, a2]); } var + _a_ = undefined, global_data = runtime.caml_get_global_data(), Stdlib = global_data.Stdlib, Stdlib_Array = global_data.Stdlib__Array, @@ -22756,45 +22805,49 @@ } var c_layout = 0, fortran_layout = 1; function cloop(arr, idx, f, col, max){ - /*<>*/ if(col === idx.length - 1) - /*<>*/ return /*<>*/ caml_ba_set_generic - (arr, idx, /*<>*/ caml_call1(f, idx)); + /*<>*/ if(col === idx.length - 1){ + /*<>*/ /*<>*/ caml_ba_set_generic + (arr, idx, /*<>*/ caml_call1(f, idx)); + /*<>*/ return; + } /*<>*/ var - /*<>*/ _am_ = + /*<>*/ _an_ = caml_check_bound(max, col)[1 + col] - 1 | 0, - /*<>*/ _al_ = 0; - if(_am_ >= 0){ - var j = _al_; + /*<>*/ _am_ = 0; + if(_an_ >= 0){ + var j = _am_; for(;;){ /*<>*/ caml_check_bound(idx, col)[1 + col] = j; /*<>*/ cloop(arr, idx, f, col + 1 | 0, max); /*<>*/ /*<>*/ var - _an_ = j + 1 | 0; - if(_am_ === j) break; - var j = _an_; + _ao_ = j + 1 | 0; + if(_an_ === j) break; + var j = _ao_; } } - return 0; + return; /*<>*/ } function floop(arr, idx, f, col, max){ - /*<>*/ if(0 > col) - /*<>*/ return /*<>*/ caml_ba_set_generic - (arr, idx, /*<>*/ caml_call1(f, idx)); + /*<>*/ if(0 > col){ + /*<>*/ /*<>*/ caml_ba_set_generic + (arr, idx, /*<>*/ caml_call1(f, idx)); + /*<>*/ return; + } /*<>*/ var - /*<>*/ _aj_ = caml_check_bound(max, col)[1 + col], - /*<>*/ _ai_ = 1; - if(_aj_ >= 1){ - var j = _ai_; + /*<>*/ _ak_ = caml_check_bound(max, col)[1 + col], + /*<>*/ _aj_ = 1; + if(_ak_ >= 1){ + var j = _aj_; for(;;){ /*<>*/ caml_check_bound(idx, col)[1 + col] = j; /*<>*/ floop(arr, idx, f, col - 1 | 0, max); /*<>*/ /*<>*/ var - _ak_ = j + 1 | 0; - if(_aj_ === j) break; - var j = _ak_; + _al_ = j + 1 | 0; + if(_ak_ === j) break; + var j = _al_; } } - return 0; + return; /*<>*/ } function init(kind, layout, dims, f){ /*<>*/ var @@ -22823,31 +22876,31 @@ /*<>*/ caml_ba_num_dims(a), /*<>*/ d = /*<>*/ caml_make_vect(n, 0), - /*<>*/ _af_ = n - 1 | 0, - /*<>*/ _ae_ = 0; - if(_af_ >= 0){ - var i = _ae_; + /*<>*/ _ag_ = n - 1 | 0, + /*<>*/ _af_ = 0; + if(_ag_ >= 0){ + var i = _af_; for(;;){ /*<>*/ /*<>*/ var - _ag_ = /*<>*/ runtime.caml_ba_dim(a, i); - /*<>*/ caml_check_bound(d, i)[1 + i] = _ag_; + _ah_ = /*<>*/ runtime.caml_ba_dim(a, i); + /*<>*/ caml_check_bound(d, i)[1 + i] = _ah_; /*<>*/ /*<>*/ var - _ah_ = i + 1 | 0; - if(_af_ === i) break; - var i = _ah_; + _ai_ = i + 1 | 0; + if(_ag_ === i) break; + var i = _ai_; } } /*<>*/ return d; /*<>*/ } function size_in_bytes(arr){ /*<>*/ var - /*<>*/ _ac_ = dims(arr), - /*<>*/ _ad_ = + /*<>*/ _ad_ = dims(arr), + /*<>*/ _ae_ = /*<>*/ caml_call3 - (Stdlib_Array[17], caml_mul, 1, _ac_); + (Stdlib_Array[17], caml_mul, 1, _ad_); /*<>*/ return /*<>*/ caml_mul (kind_size_in_bytes( /*<>*/ caml_ba_kind(arr)), - _ad_); + _ae_); /*<>*/ } function create(kind, layout){ /*<>*/ return /*<>*/ caml_ba_create @@ -22858,9 +22911,9 @@ (arr, [0]); /*<>*/ } function set(arr){ - /*<>*/ /*<>*/ var _aa_ = [0]; - /*<>*/ return function(_ab_){ - /*<>*/ return caml_ba_set_generic(arr, _aa_, _ab_);}; + /*<>*/ /*<>*/ var _ab_ = [0]; + /*<>*/ return function(_ac_){ + /*<>*/ return caml_ba_set_generic(arr, _ab_, _ac_);}; /*<>*/ } function size_in_bytes$0(arr){ /*<>*/ return kind_size_in_bytes @@ -22878,10 +22931,10 @@ /*<>*/ } function size_in_bytes$1(arr){ /*<>*/ /*<>*/ var - _$_ = /*<>*/ caml_ba_dim_1(arr); + _aa_ = /*<>*/ caml_ba_dim_1(arr); /*<>*/ return /*<>*/ caml_mul (kind_size_in_bytes( /*<>*/ caml_ba_kind(arr)), - _$_); + _aa_); /*<>*/ } function slice(a, n){ /*<>*/ return /*<>*/ runtime.caml_ba_layout @@ -22893,32 +22946,32 @@ /*<>*/ /*<>*/ var arr = create$0(kind, layout, dim); /*<>*/ if(layout){ - /*<>*/ /*<>*/ var _Z_ = 1; + /*<>*/ /*<>*/ var ___ = 1; if(dim >= 1){ - var i$0 = _Z_; + var i$0 = ___; for(;;){ /*<>*/ /*<>*/ caml_ba_set_1 (arr, i$0, /*<>*/ caml_call1(f, i$0)); /*<>*/ /*<>*/ var - ___ = i$0 + 1 | 0; + _$_ = i$0 + 1 | 0; if(dim === i$0) break; - var i$0 = ___; + var i$0 = _$_; } } /*<>*/ return arr; } /*<>*/ var - _X_ = dim - 1 | 0, - /*<>*/ _W_ = 0; - if(_X_ >= 0){ - var i = _W_; + _Y_ = dim - 1 | 0, + /*<>*/ _X_ = 0; + if(_Y_ >= 0){ + var i = _X_; for(;;){ /*<>*/ /*<>*/ caml_ba_set_1 (arr, i, /*<>*/ caml_call1(f, i)); /*<>*/ /*<>*/ var - _Y_ = i + 1 | 0; - if(_X_ === i) break; - var i = _Y_; + _Z_ = i + 1 | 0; + if(_Y_ === i) break; + var i = _Z_; } } /*<>*/ return arr; @@ -22927,17 +22980,17 @@ /*<>*/ var /*<>*/ ba = create$0(kind, layout, data.length - 1), /*<>*/ ofs = layout ? 1 : 0, - _U_ = data.length - 1 - 1 | 0, - _T_ = 0; - if(_U_ >= 0){ - var i = _T_; + _V_ = data.length - 1 - 1 | 0, + _U_ = 0; + if(_V_ >= 0){ + var i = _U_; for(;;){ /*<>*/ /*<>*/ caml_ba_set_1 (ba, i + ofs | 0, caml_check_bound(data, i)[1 + i]); /*<>*/ /*<>*/ var - _V_ = i + 1 | 0; - if(_U_ === i) break; - var i = _V_; + _W_ = i + 1 | 0; + if(_V_ === i) break; + var i = _W_; } } /*<>*/ return ba; @@ -22948,16 +23001,16 @@ /*<>*/ } function size_in_bytes$2(arr){ /*<>*/ var - /*<>*/ _R_ = + /*<>*/ _S_ = /*<>*/ caml_ba_dim_2(arr), - /*<>*/ _S_ = + /*<>*/ _T_ = /*<>*/ caml_ba_dim_1(arr); return caml_mul ( /*<>*/ caml_mul (kind_size_in_bytes ( /*<>*/ caml_ba_kind(arr)), - _S_), - _R_); + _T_), + _S_); /*<>*/ } function slice_left(a, n){ /*<>*/ return /*<>*/ caml_ba_slice @@ -22971,54 +23024,54 @@ /*<>*/ /*<>*/ var arr = create$1(kind, layout, dim1, dim2); /*<>*/ if(layout){ - /*<>*/ /*<>*/ var _N_ = 1; + /*<>*/ /*<>*/ var _O_ = 1; if(dim2 >= 1){ - var j$0 = _N_; + var j$0 = _O_; for(;;){ - /*<>*/ /*<>*/ var _O_ = 1; + /*<>*/ /*<>*/ var _P_ = 1; if(dim1 >= 1){ - var i$0 = _O_; + var i$0 = _P_; for(;;){ /*<>*/ /*<>*/ caml_ba_set_2 (arr, i$0, j$0, /*<>*/ caml_call2(f, i$0, j$0)); /*<>*/ /*<>*/ var - _Q_ = i$0 + 1 | 0; + _R_ = i$0 + 1 | 0; if(dim1 === i$0) break; - var i$0 = _Q_; + var i$0 = _R_; } } /*<>*/ /*<>*/ var - _P_ = j$0 + 1 | 0; + _Q_ = j$0 + 1 | 0; if(dim2 === j$0) break; - var j$0 = _P_; + var j$0 = _Q_; } } /*<>*/ return arr; } /*<>*/ var - _I_ = dim1 - 1 | 0, - /*<>*/ _H_ = 0; - if(_I_ >= 0){ - var i = _H_; + _J_ = dim1 - 1 | 0, + /*<>*/ _I_ = 0; + if(_J_ >= 0){ + var i = _I_; for(;;){ /*<>*/ var - _K_ = dim2 - 1 | 0, - /*<>*/ _J_ = 0; - if(_K_ >= 0){ - var j = _J_; + _L_ = dim2 - 1 | 0, + /*<>*/ _K_ = 0; + if(_L_ >= 0){ + var j = _K_; for(;;){ /*<>*/ /*<>*/ caml_ba_set_2 (arr, i, j, /*<>*/ caml_call2(f, i, j)); /*<>*/ /*<>*/ var - _M_ = j + 1 | 0; - if(_K_ === j) break; - var j = _M_; + _N_ = j + 1 | 0; + if(_L_ === j) break; + var j = _N_; } } /*<>*/ /*<>*/ var - _L_ = i + 1 | 0; - if(_I_ === i) break; - var i = _L_; + _M_ = i + 1 | 0; + if(_J_ === i) break; + var i = _M_; } } /*<>*/ return arr; @@ -23030,10 +23083,10 @@ 0 === dim1 ? 0 : caml_check_bound(data, 0)[1].length - 1, /*<>*/ ba = create$1(kind, layout, dim1, dim2), /*<>*/ ofs = layout ? 1 : 0, - /*<>*/ _C_ = dim1 - 1 | 0, - _B_ = 0; - if(_C_ >= 0){ - var i = _B_; + /*<>*/ _D_ = dim1 - 1 | 0, + _C_ = 0; + if(_D_ >= 0){ + var i = _C_; for(;;){ /*<>*/ /*<>*/ var row = caml_check_bound(data, i)[1 + i]; @@ -23041,23 +23094,23 @@ /*<>*/ /*<>*/ caml_call1 (Stdlib[1], cst_Bigarray_Array2_of_array_n); /*<>*/ var - /*<>*/ _E_ = dim2 - 1 | 0, - /*<>*/ _D_ = 0; - if(_E_ >= 0){ - var j = _D_; + /*<>*/ _F_ = dim2 - 1 | 0, + /*<>*/ _E_ = 0; + if(_F_ >= 0){ + var j = _E_; for(;;){ /*<>*/ /*<>*/ caml_ba_set_2 (ba, i + ofs | 0, j + ofs | 0, caml_check_bound(row, j)[1 + j]); /*<>*/ /*<>*/ var - _G_ = j + 1 | 0; - if(_E_ === j) break; - var j = _G_; + _H_ = j + 1 | 0; + if(_F_ === j) break; + var j = _H_; } } /*<>*/ /*<>*/ var - _F_ = i + 1 | 0; - if(_C_ === i) break; - var i = _F_; + _G_ = i + 1 | 0; + if(_D_ === i) break; + var i = _G_; } } /*<>*/ return ba; @@ -23068,20 +23121,20 @@ /*<>*/ } function size_in_bytes$3(arr){ /*<>*/ var - /*<>*/ _y_ = + /*<>*/ _z_ = /*<>*/ runtime.caml_ba_dim_3(arr), - /*<>*/ _z_ = + /*<>*/ _A_ = /*<>*/ caml_ba_dim_2(arr), - /*<>*/ _A_ = + /*<>*/ _B_ = /*<>*/ caml_ba_dim_1(arr); return caml_mul (caml_mul ( /*<>*/ caml_mul (kind_size_in_bytes ( /*<>*/ caml_ba_kind(arr)), - _A_), - _z_), - _y_); + _B_), + _A_), + _z_); /*<>*/ } function slice_left_1(a, n, m){ /*<>*/ return /*<>*/ caml_ba_slice @@ -23103,17 +23156,17 @@ /*<>*/ /*<>*/ var arr = create$2(kind, layout, dim1, dim2, dim3); /*<>*/ if(layout){ - /*<>*/ /*<>*/ var _s_ = 1; + /*<>*/ /*<>*/ var _t_ = 1; if(dim3 >= 1){ - var k$0 = _s_; + var k$0 = _t_; for(;;){ - /*<>*/ /*<>*/ var _t_ = 1; + /*<>*/ /*<>*/ var _u_ = 1; if(dim2 >= 1){ - var j$0 = _t_; + var j$0 = _u_; for(;;){ - /*<>*/ /*<>*/ var _v_ = 1; + /*<>*/ /*<>*/ var _w_ = 1; if(dim1 >= 1){ - var i$0 = _v_; + var i$0 = _w_; for(;;){ /*<>*/ /*<>*/ caml_ba_set_3 (arr, @@ -23122,61 +23175,61 @@ k$0, /*<>*/ caml_call3(f, i$0, j$0, k$0)); /*<>*/ /*<>*/ var - _x_ = i$0 + 1 | 0; + _y_ = i$0 + 1 | 0; if(dim1 === i$0) break; - var i$0 = _x_; + var i$0 = _y_; } } /*<>*/ /*<>*/ var - _w_ = j$0 + 1 | 0; + _x_ = j$0 + 1 | 0; if(dim2 === j$0) break; - var j$0 = _w_; + var j$0 = _x_; } } /*<>*/ /*<>*/ var - _u_ = k$0 + 1 | 0; + _v_ = k$0 + 1 | 0; if(dim3 === k$0) break; - var k$0 = _u_; + var k$0 = _v_; } } /*<>*/ return arr; } /*<>*/ var - _k_ = dim1 - 1 | 0, - /*<>*/ _j_ = 0; - if(_k_ >= 0){ - var i = _j_; + _l_ = dim1 - 1 | 0, + /*<>*/ _k_ = 0; + if(_l_ >= 0){ + var i = _k_; for(;;){ /*<>*/ var - _m_ = dim2 - 1 | 0, - /*<>*/ _l_ = 0; - if(_m_ >= 0){ - var j = _l_; + _n_ = dim2 - 1 | 0, + /*<>*/ _m_ = 0; + if(_n_ >= 0){ + var j = _m_; for(;;){ /*<>*/ var - _p_ = dim3 - 1 | 0, - /*<>*/ _o_ = 0; - if(_p_ >= 0){ - var k = _o_; + _q_ = dim3 - 1 | 0, + /*<>*/ _p_ = 0; + if(_q_ >= 0){ + var k = _p_; for(;;){ /*<>*/ /*<>*/ caml_ba_set_3 (arr, i, j, k, /*<>*/ caml_call3(f, i, j, k)); /*<>*/ /*<>*/ var - _r_ = k + 1 | 0; - if(_p_ === k) break; - var k = _r_; + _s_ = k + 1 | 0; + if(_q_ === k) break; + var k = _s_; } } /*<>*/ /*<>*/ var - _q_ = j + 1 | 0; - if(_m_ === j) break; - var j = _q_; + _r_ = j + 1 | 0; + if(_n_ === j) break; + var j = _r_; } } /*<>*/ /*<>*/ var - _n_ = i + 1 | 0; - if(_k_ === i) break; - var i = _n_; + _o_ = i + 1 | 0; + if(_l_ === i) break; + var i = _o_; } } /*<>*/ return arr; @@ -23192,10 +23245,10 @@ : caml_check_bound(caml_check_bound(data, 0)[1], 0)[1].length - 1, /*<>*/ ba = create$2(kind, layout, dim1, dim2, dim3), /*<>*/ ofs = layout ? 1 : 0, - /*<>*/ _b_ = dim1 - 1 | 0, - _a_ = 0; - if(_b_ >= 0){ - var i = _a_; + /*<>*/ _c_ = dim1 - 1 | 0, + _b_ = 0; + if(_c_ >= 0){ + var i = _b_; for(;;){ /*<>*/ /*<>*/ var row = caml_check_bound(data, i)[1 + i]; @@ -23203,10 +23256,10 @@ /*<>*/ /*<>*/ caml_call1 (Stdlib[1], cst_Bigarray_Array3_of_array_n); /*<>*/ var - /*<>*/ _d_ = dim2 - 1 | 0, - /*<>*/ _c_ = 0; - if(_d_ >= 0){ - var j = _c_; + /*<>*/ _e_ = dim2 - 1 | 0, + /*<>*/ _d_ = 0; + if(_e_ >= 0){ + var j = _d_; for(;;){ /*<>*/ /*<>*/ var col = caml_check_bound(row, j)[1 + j]; @@ -23214,10 +23267,10 @@ /*<>*/ /*<>*/ caml_call1 (Stdlib[1], cst_Bigarray_Array3_of_array_n$0); /*<>*/ var - /*<>*/ _g_ = dim3 - 1 | 0, - /*<>*/ _f_ = 0; - if(_g_ >= 0){ - var k = _f_; + /*<>*/ _h_ = dim3 - 1 | 0, + /*<>*/ _g_ = 0; + if(_h_ >= 0){ + var k = _g_; for(;;){ /*<>*/ /*<>*/ caml_ba_set_3 (ba, @@ -23226,21 +23279,21 @@ k + ofs | 0, caml_check_bound(col, k)[1 + k]); /*<>*/ /*<>*/ var - _i_ = k + 1 | 0; - if(_g_ === k) break; - var k = _i_; + _j_ = k + 1 | 0; + if(_h_ === k) break; + var k = _j_; } } /*<>*/ /*<>*/ var - _h_ = j + 1 | 0; - if(_d_ === j) break; - var j = _h_; + _i_ = j + 1 | 0; + if(_e_ === j) break; + var j = _i_; } } /*<>*/ /*<>*/ var - _e_ = i + 1 | 0; - if(_b_ === i) break; - var i = _e_; + _f_ = i + 1 | 0; + if(_c_ === i) break; + var i = _f_; } } /*<>*/ return ba; @@ -24931,6 +24984,7 @@ Stdlib_Int = global_data.Stdlib__Int, Stdlib_Array = global_data.Stdlib__Array, Stdlib_Obj = global_data.Stdlib__Obj, + _a_ = undefined, cst_Weak_Make_hash_bucket_cann = "Weak.Make: hash bucket cannot grow more", cst_Weak_fill = "Weak.fill", cst_Weak_blit = "Weak.blit", @@ -24941,9 +24995,9 @@ cst_Weak_create = "Weak.create"; function create(l){ /*<>*/ var - _Z_ = 0 <= l ? 1 : 0, - ___ = _Z_ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : _Z_; - if(1 - ___) + ___ = 0 <= l ? 1 : 0, + _$_ = ___ ? l <= Stdlib_Obj[24][15] ? 1 : 0 : ___; + if(1 - _$_) /*<>*/ /*<>*/ caml_call1 (Stdlib[1], cst_Weak_create); /*<>*/ return /*<>*/ runtime.caml_weak_create @@ -24954,10 +25008,12 @@ /*<>*/ } function raise_if_invalid_offset(e, o, msg){ /*<>*/ var - _W_ = 0 <= o ? 1 : 0, - _X_ = _W_ ? o < length(e) ? 1 : 0 : _W_, - _Y_ = 1 - _X_; - return _Y_ ? /*<>*/ caml_call1(Stdlib[1], msg) : _Y_; + _X_ = 0 <= o ? 1 : 0, + _Y_ = _X_ ? o < length(e) ? 1 : 0 : _X_, + _Z_ = 1 - _Y_; + if(! _Z_) return _Z_; + /*<>*/ /*<>*/ caml_call1(Stdlib[1], msg); + /*<>*/ return; /*<>*/ } function set(e, o, x){ /*<>*/ raise_if_invalid_offset(e, o, cst_Weak_set); @@ -24990,13 +25046,13 @@ 0 <= o1 && (length(e1) - l | 0) >= o1 && 0 <= o2 && (length(e2) - l | 0) >= o2){ var - _U_ = 0 !== l ? 1 : 0, - _V_ = - _U_ + _V_ = 0 !== l ? 1 : 0, + _W_ = + _V_ ? /*<>*/ runtime.caml_ephe_blit_key (e1, o1, e2, o2, l) - : _U_; - /*<>*/ return _V_; + : _V_; + /*<>*/ return _W_; } /*<>*/ return /*<>*/ caml_call1 (Stdlib[1], cst_Weak_blit); @@ -25004,14 +25060,14 @@ function fill(ar, ofs, len, x){ /*<>*/ if (0 <= ofs && 0 <= len && (length(ar) - len | 0) >= ofs){ - var _S_ = (ofs + len | 0) - 1 | 0; - if(_S_ >= ofs){ + var _T_ = (ofs + len | 0) - 1 | 0; + if(_T_ >= ofs){ var i = ofs; for(;;){ /*<>*/ set(ar, i, x); - /*<>*/ /*<>*/ var _T_ = i + 1 | 0; - if(_S_ === i) break; - var i = _T_; + /*<>*/ /*<>*/ var _U_ = i + 1 | 0; + if(_T_ === i) break; + var i = _U_; } } return 0; @@ -25039,16 +25095,16 @@ /*<>*/ } function clear(t){ /*<>*/ var - _Q_ = t[1].length - 1 - 1 | 0, - /*<>*/ _P_ = 0; - if(_Q_ >= 0){ - var i = _P_; + _R_ = t[1].length - 1 - 1 | 0, + /*<>*/ _Q_ = 0; + if(_R_ >= 0){ + var i = _Q_; for(;;){ /*<>*/ caml_check_bound(t[1], i)[1 + i] = emptybucket; /*<>*/ caml_check_bound(t[2], i)[1 + i] = [0]; - /*<>*/ /*<>*/ var _R_ = i + 1 | 0; - if(_Q_ === i) break; - var i = _R_; + /*<>*/ /*<>*/ var _S_ = i + 1 | 0; + if(_R_ === i) break; + var i = _S_; } } t[3] = limit; @@ -25056,8 +25112,8 @@ return 0; /*<>*/ } function fold(f, t, init){ - /*<>*/ var _N_ = t[1], i = 0; - /*<>*/ function _O_(b, accu$1){ + /*<>*/ var _O_ = t[1], i = 0; + /*<>*/ function _P_(b, accu$1){ var i$0 = i, accu = accu$1; /*<>*/ for(;;){ if(length(b) <= i$0) /*<>*/ return accu; @@ -25076,11 +25132,11 @@ } } /*<>*/ return /*<>*/ caml_call3 - (Stdlib_Array[19], _O_, _N_, init); + (Stdlib_Array[19], _P_, _O_, init); /*<>*/ } function iter(f, t){ - /*<>*/ var _L_ = t[1], i = 0; - /*<>*/ function _M_(b){ + /*<>*/ var _M_ = t[1], i = 0; + /*<>*/ function _N_(b){ var i$0 = i; /*<>*/ for(;;){ if(length(b) <= i$0) /*<>*/ return 0; @@ -25096,15 +25152,15 @@ } } /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Array[11], _M_, _L_); + (Stdlib_Array[11], _N_, _M_); /*<>*/ } function count_bucket(i, b, accu){ /*<>*/ var i$0 = i, accu$0 = accu; /*<>*/ for(;;){ if(length(b) <= i$0) /*<>*/ return accu$0; /*<>*/ var - /*<>*/ _K_ = check(b, i$0) ? 1 : 0, - accu$1 = accu$0 + _K_ | 0, + /*<>*/ _L_ = check(b, i$0) ? 1 : 0, + accu$1 = accu$0 + _L_ | 0, i$1 = i$0 + 1 | 0, i$0 = i$1, accu$0 = accu$1; @@ -25112,14 +25168,14 @@ /*<>*/ } function count(t){ /*<>*/ var - /*<>*/ _E_ = 0, - _F_ = t[1], - _G_ = 0; - /*<>*/ function _H_(_I_, _J_){ - /*<>*/ return count_bucket(_G_, _I_, _J_); + /*<>*/ _F_ = 0, + _G_ = t[1], + _H_ = 0; + /*<>*/ function _I_(_J_, _K_){ + /*<>*/ return count_bucket(_H_, _J_, _K_); } /*<>*/ return /*<>*/ caml_call3 - (Stdlib_Array[19], _H_, _F_, _E_); + (Stdlib_Array[19], _I_, _G_, _F_); /*<>*/ } function add_aux(t, setter, d, h, index){ /*<>*/ var @@ -25152,18 +25208,18 @@ /*<>*/ caml_check_bound(newhashes, sz)[1 + sz] = h; /*<>*/ caml_check_bound(t[1], index)[1 + index] = newbucket$0; /*<>*/ caml_check_bound(t[2], index)[1 + index] = newhashes; - var _A_ = sz <= t[3] ? 1 : 0, _B_ = _A_ ? t[3] < newsz ? 1 : 0 : _A_; - if(_B_){ + var _B_ = sz <= t[3] ? 1 : 0, _C_ = _B_ ? t[3] < newsz ? 1 : 0 : _B_; + if(_C_){ t[4] = t[4] + 1 | 0; var i$4 = 0; for(;;){ /*<>*/ var - _q_ = t[5], + _r_ = t[5], /*<>*/ bucket = - caml_check_bound(t[1], _q_)[1 + _q_], - /*<>*/ _r_ = t[5], + caml_check_bound(t[1], _r_)[1 + _r_], + /*<>*/ _s_ = t[5], /*<>*/ hbucket = - caml_check_bound(t[2], _r_)[1 + _r_], + caml_check_bound(t[2], _s_)[1 + _s_], /*<>*/ len = length(bucket), prev_len = (((len - 3 | 0) * 2 | 0) + 2 | 0) / 3 | 0, /*<>*/ live = count_bucket(0, bucket, 0); @@ -25175,28 +25231,28 @@ /*<>*/ for(;;){ if(prev_len > j){ if(0 === prev_len){ - var _t_ = t[5]; - /*<>*/ caml_check_bound(t[1], _t_)[1 + _t_] = emptybucket; var _u_ = t[5]; - /*<>*/ caml_check_bound(t[2], _u_)[1 + _u_] = [0]; + /*<>*/ caml_check_bound(t[1], _u_)[1 + _u_] = emptybucket; + var _v_ = t[5]; + /*<>*/ caml_check_bound(t[2], _v_)[1 + _v_] = [0]; } else{ /*<>*/ /*<>*/ var newbucket = create(prev_len); /*<>*/ blit(bucket, 0, newbucket, 0, prev_len); - var _x_ = t[5]; - /*<>*/ caml_check_bound(t[1], _x_)[1 + _x_] = newbucket; + var _y_ = t[5]; + /*<>*/ caml_check_bound(t[1], _y_)[1 + _y_] = newbucket; /*<>*/ var - /*<>*/ _y_ = + /*<>*/ _z_ = /*<>*/ caml_call3 (Stdlib_Array[5], hbucket, 0, prev_len), - _z_ = t[5]; - /*<>*/ caml_check_bound(t[2], _z_)[1 + _z_] = _y_; + _A_ = t[5]; + /*<>*/ caml_check_bound(t[2], _A_)[1 + _A_] = _z_; } var - _v_ = t[3] < len ? 1 : 0, - _w_ = _v_ ? prev_len <= t[3] ? 1 : 0 : _v_; - if(_w_) t[4] = t[4] - 1 | 0; + _w_ = t[3] < len ? 1 : 0, + _x_ = _w_ ? prev_len <= t[3] ? 1 : 0 : _w_; + if(_x_) t[4] = t[4] - 1 | 0; break; } /*<>*/ if(check(bucket, i$0)) @@ -25204,8 +25260,8 @@ else if(check(bucket, j)){ /*<>*/ blit(bucket, j, bucket, i$0, 1); /*<>*/ /*<>*/ var - _s_ = caml_check_bound(hbucket, j)[1 + j]; - /*<>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _s_; + _t_ = caml_check_bound(hbucket, j)[1 + j]; + /*<>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _t_; /*<>*/ var /*<>*/ j$0 = j - 1 | 0, i$2 = i$0 + 1 | 0, @@ -25220,13 +25276,13 @@ } t[5] = caml_mod(t[5] + 1 | 0, t[1].length - 1); /*<>*/ /*<>*/ var - _D_ = i$4 + 1 | 0; + _E_ = i$4 + 1 | 0; if(2 === i$4) break; - var i$4 = _D_; + var i$4 = _E_; } } - var _C_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0; - if(! _C_) return _C_; + var _D_ = ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0; + if(! _D_) return _D_; /*<>*/ var oldlen = t[1].length - 1, /*<>*/ newlen = @@ -25237,9 +25293,9 @@ if(oldlen < newlen){ /*<>*/ var /*<>*/ newt = create$0(newlen), - _o_ = t[1], + _p_ = t[1], i = 0, - /*<>*/ _p_ = + /*<>*/ _q_ = function(j, ob){ var oi = i; /*<>*/ for(;;){ @@ -25265,7 +25321,7 @@ } }; /*<>*/ /*<>*/ caml_call2 - (Stdlib_Array[12], _p_, _o_); + (Stdlib_Array[12], _q_, _p_); t[1] = newt[1]; t[2] = newt[2]; t[3] = newt[3]; @@ -25329,7 +25385,7 @@ } /*<>*/ } function find_opt(t, d){ - /*<>*/ function _n_(h, i){ + /*<>*/ function _o_(h, i){ /*<>*/ return 0; /*<>*/ } /*<>*/ return find_aux @@ -25338,10 +25394,10 @@ function(b, i, o, v){ /*<>*/ return o; /*<>*/ }, - _n_); + _o_); /*<>*/ } function merge(t, d){ - function _m_(h, i){ + function _n_(h, i){ /*<>*/ add_aux(t, set, [0, d], h, i); /*<>*/ return d; /*<>*/ } @@ -25351,10 +25407,10 @@ function(b, i, o, v){ /*<>*/ return v; /*<>*/ }, - _m_); + _n_); /*<>*/ } function find(t, d){ - /*<>*/ function _l_(h, i){ + /*<>*/ function _m_(h, i){ /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace (Stdlib[8], 1); /*<>*/ } @@ -25364,10 +25420,10 @@ function(b, i, o, v){ /*<>*/ return v; /*<>*/ }, - _l_); + _m_); /*<>*/ } function remove(t, d){ - /*<>*/ function _k_(h, i){ + /*<>*/ function _l_(h, i){ /*<>*/ return 0; /*<>*/ } /*<>*/ return find_aux @@ -25376,10 +25432,10 @@ function(b, i, o, v){ /*<>*/ return set(b, i, 0); /*<>*/ }, - _k_); + _l_); /*<>*/ } function mem(t, d){ - /*<>*/ function _j_(h, i){ + /*<>*/ function _k_(h, i){ /*<>*/ return 0; /*<>*/ } /*<>*/ return find_aux @@ -25388,7 +25444,7 @@ function(b, i, o, v){ /*<>*/ return 1; /*<>*/ }, - _j_); + _k_); /*<>*/ } function find_all(t, d){ /*<>*/ var @@ -25431,17 +25487,17 @@ /*<>*/ caml_call2(Stdlib_Array[13], length, t[1]); /*<>*/ /*<>*/ caml_call2 (Stdlib_Array[34], runtime.caml_int_compare, lens); - var _a_ = 0; - function _b_(_i_, _h_){ /*<>*/ return _i_ + _h_ | 0;} + var _b_ = 0; + function _c_(_j_, _i_){ /*<>*/ return _j_ + _i_ | 0;} /*<>*/ var /*<>*/ totlen = - /*<>*/ caml_call3(Stdlib_Array[17], _b_, _a_, lens), - /*<>*/ _c_ = len - 1 | 0, - _e_ = len / 2 | 0, - /*<>*/ _d_ = caml_check_bound(lens, _c_)[1 + _c_], - /*<>*/ _f_ = caml_check_bound(lens, _e_)[1 + _e_], - /*<>*/ _g_ = caml_check_bound(lens, 0)[1]; - /*<>*/ return [0, len, count(t), totlen, _g_, _f_, _d_]; + /*<>*/ caml_call3(Stdlib_Array[17], _c_, _b_, lens), + /*<>*/ _d_ = len - 1 | 0, + _f_ = len / 2 | 0, + /*<>*/ _e_ = caml_check_bound(lens, _d_)[1 + _d_], + /*<>*/ _g_ = caml_check_bound(lens, _f_)[1 + _f_], + /*<>*/ _h_ = caml_check_bound(lens, 0)[1]; + /*<>*/ return [0, len, count(t), totlen, _h_, _g_, _e_]; /*<>*/ } /*<>*/ return [0, create$0, @@ -25498,6 +25554,7 @@ : runtime.caml_call_gen(f, [a0, a1, a2, a3]); } var + _m_ = undefined, global_data = runtime.caml_get_global_data(), cst$14 = ".", cst$11 = cst$15, @@ -25547,25 +25604,28 @@ /*<>*/ } var pp_infinity = 1000000010; function pp_output_string(state, s){ - /*<>*/ return caml_call3 - (state[17], s, 0, caml_ml_string_length(s)); + /*<>*/ caml_call3 + (state[17], s, 0, caml_ml_string_length(s)); + return; /*<>*/ } function pp_output_newline(state){ - /*<>*/ return /*<>*/ caml_call1 - (state[19], 0); + /*<>*/ /*<>*/ caml_call1 + (state[19], 0); + /*<>*/ return; /*<>*/ } function format_pp_text(state, size, text){ /*<>*/ state[9] = state[9] - size | 0; /*<>*/ pp_output_string(state, text); state[11] = 0; - return 0; + return; /*<>*/ } function format_string(state, s){ /*<>*/ /*<>*/ var - _bQ_ = /*<>*/ runtime.caml_string_notequal(s, cst$16); - /*<>*/ return _bQ_ - ? format_pp_text(state, caml_ml_string_length(s), s) - : _bQ_; + _bO_ = /*<>*/ runtime.caml_string_notequal(s, cst$16); + /*<>*/ if(! _bO_) /*<>*/ return _bO_; + /*<>*/ format_pp_text + (state, caml_ml_string_length(s), s); + /*<>*/ return; /*<>*/ } function break_new_line(state, param, width){ var after = param[3], offset = param[2], before = param[1]; @@ -25581,10 +25641,12 @@ var n = state[10]; /*<>*/ /*<>*/ caml_call1 (state[21], n); - /*<>*/ return format_string(state, after); + /*<>*/ format_string(state, after); + /*<>*/ return; } function break_line(state, width){ - /*<>*/ return break_new_line(state, _a_, width); + /*<>*/ break_new_line(state, _a_, width); + /*<>*/ return; /*<>*/ } function break_same_line(state, param){ var after = param[3], width = param[2], before = param[1]; @@ -25592,7 +25654,8 @@ state[9] = state[9] - width | 0; /*<>*/ /*<>*/ caml_call1 (state[20], width); - /*<>*/ return format_string(state, after); + /*<>*/ format_string(state, after); + /*<>*/ return; } function format_pp_token(state, size$0, param){ /*<>*/ if(typeof param === "number") @@ -25601,7 +25664,7 @@ /*<>*/ /*<>*/ var match$3 = /*<>*/ caml_call1(Stdlib_Stack[8], state[3]); - if(! match$3) /*<>*/ return 0; + if(! match$3) /*<>*/ return; /*<>*/ var tabs = match$3[1][1], /*<>*/ add_tab = @@ -25614,49 +25677,54 @@ : [0, x, add_tab(n, l)]; }; tabs[1] = add_tab(state[6] - state[9] | 0, tabs[1]); - return 0; + return; case 1: /*<>*/ /*<>*/ caml_call1 (Stdlib_Stack[5], state[2]); - /*<>*/ return 0; + /*<>*/ return; case 2: /*<>*/ /*<>*/ caml_call1 (Stdlib_Stack[5], state[3]); - /*<>*/ return 0; + /*<>*/ return; case 3: /*<>*/ /*<>*/ var match$4 = /*<>*/ caml_call1(Stdlib_Stack[8], state[2]); - if(! match$4) - /*<>*/ return pp_output_newline(state); - var width$0 = match$4[1][2]; - /*<>*/ return break_line(state, width$0); + if(match$4){ + var width$0 = match$4[1][2]; + /*<>*/ break_line(state, width$0); + /*<>*/ return; + } + /*<>*/ pp_output_newline(state); + /*<>*/ return; case 4: - var _bO_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0; - if(! _bO_) return _bO_; + var _bM_ = state[10] !== (state[6] - state[9] | 0) ? 1 : 0; + if(! _bM_) return _bM_; /*<>*/ /*<>*/ var match$1 = /*<>*/ caml_call1(Stdlib_Queue[6], state[28]); - if(! match$1) /*<>*/ return 0; + if(! match$1) /*<>*/ return; var match$2 = match$1[1], size = match$2[1], length = match$2[3]; state[12] = state[12] - length | 0; state[9] = state[9] + size | 0; - return 0; + return; default: /*<>*/ /*<>*/ var match$5 = /*<>*/ caml_call1(Stdlib_Stack[5], state[5]); - if(! match$5) /*<>*/ return 0; + if(! match$5) /*<>*/ return; /*<>*/ var tag_name = match$5[1], /*<>*/ marker = /*<>*/ caml_call1(state[25], tag_name); - /*<>*/ return pp_output_string(state, marker); + /*<>*/ pp_output_string(state, marker); + /*<>*/ return; } switch(param[0]){ case 0: var s = param[1]; - /*<>*/ return format_pp_text(state, size$0, s); + /*<>*/ format_pp_text(state, size$0, s); + /*<>*/ return; case 1: /*<>*/ var breaks = param[2], @@ -25665,42 +25733,46 @@ before = breaks[1], /*<>*/ match$6 = /*<>*/ caml_call1(Stdlib_Stack[8], state[2]); - if(! match$6) /*<>*/ return 0; + if(! match$6) /*<>*/ return; var match$7 = match$6[1], width$1 = match$7[2], box_type$0 = match$7[1]; /*<>*/ switch(box_type$0){ case 0: - /*<>*/ return break_same_line(state, fits); + /*<>*/ break_same_line(state, fits); + /*<>*/ return; case 1: - /*<>*/ return break_new_line - (state, breaks, width$1); + /*<>*/ break_new_line(state, breaks, width$1); + /*<>*/ return; case 2: - /*<>*/ return break_new_line - (state, breaks, width$1); + /*<>*/ break_new_line(state, breaks, width$1); + /*<>*/ return; case 3: - return state[9] < (size$0 + caml_ml_string_length(before) | 0) - ? break_new_line(state, breaks, width$1) - : break_same_line(state, fits); + if(state[9] < (size$0 + caml_ml_string_length(before) | 0)){ + /*<>*/ break_new_line(state, breaks, width$1); + /*<>*/ return; + } + /*<>*/ break_same_line(state, fits); + /*<>*/ return; case 4: - return state[11] - ? break_same_line(state, fits) - : state - [9] - < (size$0 + caml_ml_string_length(before) | 0) - ? break_new_line(state, breaks, width$1) - : ((state - [6] - - width$1 - | 0) - + off - | 0) - < state[10] - ? break_new_line(state, breaks, width$1) - : break_same_line(state, fits); + if(state[11]){ + /*<>*/ break_same_line(state, fits); + /*<>*/ return; + } + if(state[9] < (size$0 + caml_ml_string_length(before) | 0)){ + /*<>*/ break_new_line(state, breaks, width$1); + /*<>*/ return; + } + if(((state[6] - width$1 | 0) + off | 0) < state[10]){ + /*<>*/ break_new_line(state, breaks, width$1); + /*<>*/ return; + } + /*<>*/ break_same_line(state, fits); + /*<>*/ return; default: - /*<>*/ return break_same_line(state, fits); + /*<>*/ break_same_line(state, fits); + /*<>*/ return; } case 2: /*<>*/ var @@ -25709,7 +25781,7 @@ insertion_point = state[6] - state[9] | 0, /*<>*/ match$8 = /*<>*/ caml_call1(Stdlib_Stack[8], state[3]); - if(! match$8) /*<>*/ return 0; + if(! match$8) /*<>*/ return; /*<>*/ var tabs$0 = match$8[1][1], /*<>*/ match$9 = tabs$0[1]; @@ -25719,21 +25791,25 @@ if(param$0){ var tail = param$0[2], head = param$0[1]; if(insertion_point > head){var param$0 = tail; continue;} - var _bP_ = head; + var _bN_ = head; } else - var _bP_ = first; - var tab = _bP_; + var _bN_ = first; + var tab = _bN_; break; } } else var tab = insertion_point; var offset = tab - insertion_point | 0; - /*<>*/ return 0 <= offset - ? break_same_line(state, [0, cst$0, offset + n | 0, cst]) - : break_new_line - (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]); + /*<>*/ if(0 <= offset){ + /*<>*/ break_same_line + (state, [0, cst$0, offset + n | 0, cst]); + /*<>*/ return; + } + /*<>*/ break_new_line + (state, [0, cst$2, tab + off$0 | 0, cst$1], state[6]); + /*<>*/ return; case 3: var ty = param[2], @@ -25755,19 +25831,22 @@ width$2 = state[9] - off$1 | 0, /*<>*/ box_type$1 = 1 === ty ? 1 : state[9] < size$0 ? ty : 5; - /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]); + /*<>*/ /*<>*/ caml_call2 + (Stdlib_Stack[3], [0, box_type$1, width$2], state[2]); + /*<>*/ return; case 4: var tbox = param[1]; - /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Stack[3], tbox, state[3]); + /*<>*/ /*<>*/ caml_call2 + (Stdlib_Stack[3], tbox, state[3]); + /*<>*/ return; default: /*<>*/ var tag_name$0 = param[1], /*<>*/ marker$0 = /*<>*/ caml_call1(state[24], tag_name$0); /*<>*/ pp_output_string(state, marker$0); - return caml_call2(Stdlib_Stack[3], tag_name$0, state[5]); + caml_call2(Stdlib_Stack[3], tag_name$0, state[5]); + return; } } function advance_left(state){ @@ -25781,10 +25860,10 @@ length = match$0[3], token = match$0[2], pending_count = state[13] - state[12] | 0, - /*<>*/ _bM_ = 0 <= size ? 1 : 0, - /*<>*/ _bN_ = - _bM_ || (state[9] <= pending_count ? 1 : 0); - if(! _bN_) /*<>*/ return _bN_; + /*<>*/ _bK_ = 0 <= size ? 1 : 0, + /*<>*/ _bL_ = + _bK_ || (state[9] <= pending_count ? 1 : 0); + if(! _bL_) /*<>*/ return _bL_; /*<>*/ /*<>*/ caml_call1 (Stdlib_Queue[5], state[28]); /*<>*/ /*<>*/ var @@ -25806,48 +25885,40 @@ (Stdlib_Stack[9], stack); /*<>*/ /*<>*/ var queue_elem = [0, unknown, _b_, 0]; - /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Stack[3], [0, -1, queue_elem], stack); + /*<>*/ /*<>*/ caml_call2 + (Stdlib_Stack[3], [0, -1, queue_elem], stack); + /*<>*/ return; /*<>*/ } function set_size(state, ty){ /*<>*/ /*<>*/ var match = /*<>*/ caml_call1(Stdlib_Stack[8], state[1]); - if(! match) /*<>*/ return 0; + if(! match) /*<>*/ return; /*<>*/ var match$0 = match[1], queue_elem = match$0[2], left_total = match$0[1], /*<>*/ size = queue_elem[1]; - if(left_total < state[12]) return initialize_scan_stack(state[1]); - var _bI_ = queue_elem[2]; - if(typeof _bI_ !== "number") - switch(_bI_[0]){ + if(left_total < state[12]){initialize_scan_stack(state[1]); return;} + var _bJ_ = queue_elem[2]; + if(typeof _bJ_ !== "number") + switch(_bJ_[0]){ case 3: - var - _bK_ = 1 - ty, - _bL_ = - _bK_ - ? (queue_elem - [1] - = state[13] + size | 0, - /*<>*/ caml_call1(Stdlib_Stack[5], state[1]), - 0) - : _bK_; - /*<>*/ return _bL_; + if(1 - ty){ + queue_elem[1] = state[13] + size | 0; + /*<>*/ /*<>*/ caml_call1 + (Stdlib_Stack[5], state[1]); + } + /*<>*/ return; case 1: case 2: - var - _bJ_ = - ty - ? (queue_elem - [1] - = state[13] + size | 0, - /*<>*/ caml_call1(Stdlib_Stack[5], state[1]), - 0) - : ty; - /*<>*/ return _bJ_; + if(ty){ + queue_elem[1] = state[13] + size | 0; + /*<>*/ /*<>*/ caml_call1 + (Stdlib_Stack[5], state[1]); + } + /*<>*/ return; } - /*<>*/ return 0; + /*<>*/ return; /*<>*/ } function scan_push(state, b, token){ /*<>*/ pp_enqueue(state, token); @@ -25865,26 +25936,26 @@ /*<>*/ elem = [0, size, [3, indent, br_ty], 0]; /*<>*/ return scan_push(state, 0, elem); } - var _bH_ = state[14] === state[15] ? 1 : 0; - if(! _bH_) return _bH_; + var _bI_ = state[14] === state[15] ? 1 : 0; + if(! _bI_) return _bI_; var s = state[16]; /*<>*/ return enqueue_string_as (state, caml_ml_string_length(s), s); /*<>*/ } function pp_close_box(state, param){ - /*<>*/ var _bF_ = 1 < state[14] ? 1 : 0; - if(_bF_){ + /*<>*/ var _bG_ = 1 < state[14] ? 1 : 0; + if(_bG_){ if(state[14] < state[15]){ /*<>*/ pp_enqueue(state, [0, zero, 1, 0]); /*<>*/ set_size(state, 1); /*<>*/ set_size(state, 0); } state[14] = state[14] - 1 | 0; - var _bG_ = 0; + var _bH_ = 0; } else - var _bG_ = _bF_; - return _bG_; + var _bH_ = _bG_; + return _bH_; /*<>*/ } function pp_open_stag(state, tag_name){ /*<>*/ if(state[22]){ @@ -25893,8 +25964,8 @@ /*<>*/ /*<>*/ caml_call1 (state[26], tag_name); } - var _bE_ = state[23]; - if(! _bE_) return _bE_; + var _bF_ = state[23]; + if(! _bF_) return _bF_; /*<>*/ /*<>*/ var token = [5, tag_name]; /*<>*/ return pp_enqueue(state, [0, zero, token, 0]); @@ -25902,8 +25973,8 @@ function pp_close_stag(state, param){ /*<>*/ if(state[23]) /*<>*/ pp_enqueue(state, [0, zero, 5, 0]); - var _bC_ = state[22]; - if(_bC_){ + var _bD_ = state[22]; + if(_bD_){ /*<>*/ /*<>*/ var match = /*<>*/ caml_call1(Stdlib_Stack[5], state[4]); if(match){ @@ -25911,11 +25982,11 @@ /*<>*/ return /*<>*/ caml_call1 (state[27], tag_name); } - var _bD_ = 0; + var _bE_ = 0; } else - var _bD_ = _bC_; - /*<>*/ return _bD_; + var _bE_ = _bD_; + /*<>*/ return _bE_; /*<>*/ } function pp_set_print_tags(state, b){ /*<>*/ state[22] = b; @@ -25969,25 +26040,26 @@ /*<>*/ return pp_open_box_gen(state, 0, 3); /*<>*/ } function pp_flush_queue(state, end_with_newline){ - /*<>*/ var _bA_ = state[4]; - function _bB_(param){ + /*<>*/ var _bB_ = state[4]; + function _bC_(param){ /*<>*/ return pp_close_stag(state, 0); /*<>*/ } /*<>*/ /*<>*/ caml_call2 - (Stdlib_Stack[13], _bB_, _bA_); + (Stdlib_Stack[13], _bC_, _bB_); /*<>*/ for(;;){ if(1 >= state[14]){ state[13] = pp_infinity; /*<>*/ advance_left(state); if(end_with_newline) /*<>*/ pp_output_newline(state); - /*<>*/ return pp_rinit(state); + /*<>*/ pp_rinit(state); + /*<>*/ return; } /*<>*/ pp_close_box(state, 0); } /*<>*/ } function pp_print_as_size(state, size, s){ - /*<>*/ var _bz_ = state[14] < state[15] ? 1 : 0; - return _bz_ ? enqueue_string_as(state, size, s) : _bz_; + /*<>*/ var _bA_ = state[14] < state[15] ? 1 : 0; + return _bA_ ? enqueue_string_as(state, size, s) : _bA_; /*<>*/ } function pp_print_as(state, isize, s){ /*<>*/ return pp_print_as_size(state, isize, s); @@ -26046,20 +26118,20 @@ (state[18], 0); /*<>*/ } function pp_force_newline(state, param){ - /*<>*/ var _by_ = state[14] < state[15] ? 1 : 0; - return _by_ ? enqueue_advance(state, [0, zero, 3, 0]) : _by_; + /*<>*/ var _bz_ = state[14] < state[15] ? 1 : 0; + return _bz_ ? enqueue_advance(state, [0, zero, 3, 0]) : _bz_; /*<>*/ } function pp_print_if_newline(state, param){ - /*<>*/ var _bx_ = state[14] < state[15] ? 1 : 0; - return _bx_ ? enqueue_advance(state, [0, zero, 4, 0]) : _bx_; + /*<>*/ var _by_ = state[14] < state[15] ? 1 : 0; + return _by_ ? enqueue_advance(state, [0, zero, 4, 0]) : _by_; /*<>*/ } function pp_print_custom_break(state, fits, breaks){ /*<>*/ var after = fits[3], width = fits[2], before = fits[1], - _bw_ = state[14] < state[15] ? 1 : 0; - if(! _bw_) return _bw_; + _bx_ = state[14] < state[15] ? 1 : 0; + if(! _bx_) return _bx_; /*<>*/ var size = - state[13] | 0, /*<>*/ token = [1, fits, breaks], @@ -26082,33 +26154,33 @@ /*<>*/ } function pp_open_tbox(state, param){ /*<>*/ state[14] = state[14] + 1 | 0; - var _bv_ = state[14] < state[15] ? 1 : 0; - if(! _bv_) return _bv_; + var _bw_ = state[14] < state[15] ? 1 : 0; + if(! _bw_) return _bw_; /*<>*/ /*<>*/ var elem = [0, zero, [4, [0, [0, 0]]], 0]; /*<>*/ return enqueue_advance(state, elem); /*<>*/ } function pp_close_tbox(state, param){ - /*<>*/ var _bs_ = 1 < state[14] ? 1 : 0; - if(_bs_){ - var _bt_ = state[14] < state[15] ? 1 : 0; - if(_bt_){ + /*<>*/ var _bt_ = 1 < state[14] ? 1 : 0; + if(_bt_){ + var _bu_ = state[14] < state[15] ? 1 : 0; + if(_bu_){ /*<>*/ /*<>*/ var elem = [0, zero, 2, 0]; /*<>*/ enqueue_advance(state, elem); state[14] = state[14] - 1 | 0; - var _bu_ = 0; + var _bv_ = 0; } else - var _bu_ = _bt_; + var _bv_ = _bu_; } else - var _bu_ = _bs_; - return _bu_; + var _bv_ = _bt_; + return _bv_; /*<>*/ } function pp_print_tbreak(state, width, offset){ - /*<>*/ var _br_ = state[14] < state[15] ? 1 : 0; - if(! _br_) return _br_; + /*<>*/ var _bs_ = state[14] < state[15] ? 1 : 0; + if(! _bs_) return _bs_; /*<>*/ var size = - state[13] | 0, /*<>*/ elem = [0, size, [2, width, offset], width]; @@ -26118,17 +26190,17 @@ /*<>*/ return pp_print_tbreak(state, 0, 0); /*<>*/ } function pp_set_tab(state, param){ - /*<>*/ var _bq_ = state[14] < state[15] ? 1 : 0; - if(! _bq_) return _bq_; + /*<>*/ var _br_ = state[14] < state[15] ? 1 : 0; + if(! _br_) return _br_; /*<>*/ /*<>*/ var elem = [0, zero, 0, 0]; /*<>*/ return enqueue_advance(state, elem); /*<>*/ } function pp_set_max_boxes(state, n){ /*<>*/ var - _bo_ = 1 < n ? 1 : 0, - _bp_ = _bo_ ? (state[15] = n, 0) : _bo_; - return _bp_; + _bp_ = 1 < n ? 1 : 0, + _bq_ = _bp_ ? (state[15] = n, 0) : _bp_; + return _bq_; /*<>*/ } function pp_get_max_boxes(state, param){ /*<>*/ return state[15]; @@ -26147,10 +26219,10 @@ /*<>*/ return n < 1000000010 ? n : 1000000009; /*<>*/ } function pp_set_max_indent(state, n$0){ - /*<>*/ var _bn_ = 1 < n$0 ? 1 : 0; + /*<>*/ var _bo_ = 1 < n$0 ? 1 : 0; + if(! _bo_) return _bo_; + var n$1 = state[6] - n$0 | 0, _bn_ = 1 <= n$1 ? 1 : 0; if(! _bn_) return _bn_; - var n$1 = state[6] - n$0 | 0, _bm_ = 1 <= n$1 ? 1 : 0; - if(! _bm_) return _bm_; /*<>*/ /*<>*/ var n = pp_limit(n$1); state[7] = n; state[8] = state[6] - state[7] | 0; @@ -26160,19 +26232,19 @@ /*<>*/ return state[8]; /*<>*/ } function pp_set_margin(state, n){ - /*<>*/ var _bk_ = 1 <= n ? 1 : 0; - if(! _bk_) return _bk_; + /*<>*/ var _bl_ = 1 <= n ? 1 : 0; + if(! _bl_) return _bl_; /*<>*/ /*<>*/ var n$0 = pp_limit(n); state[6] = n$0; if(state[8] <= state[6]) var new_max_indent = state[8]; else /*<>*/ var - /*<>*/ _bl_ = + /*<>*/ _bm_ = /*<>*/ caml_call2 (Stdlib_Int[11], state[6] - state[7] | 0, state[6] / 2 | 0), new_max_indent = - /*<>*/ caml_call2(Stdlib_Int[11], _bl_, 1); + /*<>*/ caml_call2(Stdlib_Int[11], _bm_, 1); /*<>*/ return pp_set_max_indent(state, new_max_indent); /*<>*/ } function validate_geometry(param){ @@ -26203,11 +26275,11 @@ /*<>*/ return pp_set_full_geometry(state, geometry); /*<>*/ var msg = match[1], - /*<>*/ _bj_ = + /*<>*/ _bk_ = /*<>*/ caml_call2 (Stdlib[28], cst_Format_pp_set_geometry, msg); /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace - ([0, Stdlib[6], _bj_], 1); + ([0, Stdlib[6], _bk_], 1); /*<>*/ } function pp_safe_set_geometry(state, max_indent, margin){ /*<>*/ /*<>*/ var @@ -26260,8 +26332,8 @@ function display_blanks(state, n){ /*<>*/ var n$0 = n; /*<>*/ for(;;){ - var _bi_ = 0 < n$0 ? 1 : 0; - if(! _bi_) return _bi_; + var _bj_ = 0 < n$0 ? 1 : 0; + if(! _bj_) return _bj_; if(80 >= n$0) /*<>*/ return /*<>*/ caml_call3 (state[17], blank_line, 0, n$0); @@ -26281,9 +26353,9 @@ (Stdlib[63], oc); /*<>*/ }; state[19] = - function(_bh_){ /*<>*/ return display_newline(state, _bh_);}; - state[20] = function(_bg_){ /*<>*/ return display_blanks(state, _bg_);}; - state[21] = function(_bf_){ /*<>*/ return display_blanks(state, _bf_);}; + function(_bi_){ /*<>*/ return display_newline(state, _bi_);}; + state[20] = function(_bh_){ /*<>*/ return display_blanks(state, _bh_);}; + state[21] = function(_bg_){ /*<>*/ return display_blanks(state, _bg_);}; return 0; /*<>*/ } function default_pp_mark_open_tag(param){ @@ -26291,23 +26363,23 @@ /*<>*/ return cst$10; /*<>*/ var s = param[2], - /*<>*/ _be_ = + /*<>*/ _bf_ = /*<>*/ caml_call2(Stdlib[28], s, cst$8); /*<>*/ return /*<>*/ caml_call2 - (Stdlib[28], cst$9, _be_); + (Stdlib[28], cst$9, _bf_); /*<>*/ } function default_pp_mark_close_tag(param){ /*<>*/ if(param[1] !== String_tag) /*<>*/ return cst$13; /*<>*/ var s = param[2], - /*<>*/ _bd_ = + /*<>*/ _be_ = /*<>*/ caml_call2(Stdlib[28], s, cst$11); /*<>*/ return /*<>*/ caml_call2 - (Stdlib[28], cst$12, _bd_); + (Stdlib[28], cst$12, _be_); /*<>*/ } - function default_pp_print_open_tag(_bc_){ /*<>*/ return 0;} - function default_pp_print_close_tag(_bb_){ /*<>*/ return 0;} + function default_pp_print_open_tag(_bd_){ /*<>*/ return 0;} + function default_pp_print_close_tag(_bc_){ /*<>*/ return 0;} function pp_make_formatter(f, g, h, i, j){ /*<>*/ var /*<>*/ pp_queue = @@ -26321,19 +26393,19 @@ /*<>*/ /*<>*/ caml_call2 (Stdlib_Stack[3], [0, 1, sys_tok], scan_stack); /*<>*/ var - _a9_ = Stdlib[19], - /*<>*/ _a__ = + _a__ = Stdlib[19], + /*<>*/ _a$_ = /*<>*/ caml_call1(Stdlib_Stack[2], 0), - /*<>*/ _a$_ = + /*<>*/ _ba_ = /*<>*/ caml_call1(Stdlib_Stack[2], 0), - /*<>*/ _ba_ = + /*<>*/ _bb_ = /*<>*/ caml_call1(Stdlib_Stack[2], 0); /*<>*/ return [0, scan_stack, /*<>*/ caml_call1(Stdlib_Stack[2], 0), + _bb_, _ba_, _a$_, - _a__, 78, 10, 68, @@ -26343,7 +26415,7 @@ 1, 1, 1, - _a9_, + _a__, cst$14, f, g, @@ -26363,30 +26435,30 @@ (out_funs[1], out_funs[2], out_funs[3], out_funs[4], out_funs[5]); /*<>*/ } function make_formatter(output, flush){ - function _a1_(_a8_){ /*<>*/ return 0;} - function _a2_(_a7_){ /*<>*/ return 0;} + function _a2_(_a9_){ /*<>*/ return 0;} + function _a3_(_a8_){ /*<>*/ return 0;} /*<>*/ /*<>*/ var ppf = pp_make_formatter - (output, flush, function(_a6_){ /*<>*/ return 0;}, _a2_, _a1_); - ppf[19] = function(_a5_){ /*<>*/ return display_newline(ppf, _a5_);}; - ppf[20] = function(_a4_){ /*<>*/ return display_blanks(ppf, _a4_);}; - ppf[21] = function(_a3_){ /*<>*/ return display_blanks(ppf, _a3_);}; + (output, flush, function(_a7_){ /*<>*/ return 0;}, _a3_, _a2_); + ppf[19] = function(_a6_){ /*<>*/ return display_newline(ppf, _a6_);}; + ppf[20] = function(_a5_){ /*<>*/ return display_blanks(ppf, _a5_);}; + ppf[21] = function(_a4_){ /*<>*/ return display_blanks(ppf, _a4_);}; /*<>*/ return ppf; /*<>*/ } function formatter_of_out_channel(oc){ - function _a0_(param){ + function _a1_(param){ /*<>*/ return /*<>*/ caml_call1 (Stdlib[63], oc); /*<>*/ } /*<>*/ return make_formatter - ( /*<>*/ caml_call1(Stdlib[69], oc), _a0_); + ( /*<>*/ caml_call1(Stdlib[69], oc), _a1_); /*<>*/ } function formatter_of_buffer(b){ - /*<>*/ function _aY_(_aZ_){ /*<>*/ return 0;} + /*<>*/ function _aZ_(_a0_){ /*<>*/ return 0;} /*<>*/ return make_formatter ( /*<>*/ caml_call1(Stdlib_Buffer[18], b), - _aY_); + _aZ_); /*<>*/ } var pp_buffer_size = 512; function pp_make_buffer(param){ @@ -26417,9 +26489,9 @@ (Stdlib_Domain[10][3], str_formatter_key, str_formatter); /*<>*/ function buffered_out_string(key, str, ofs, len){ /*<>*/ /*<>*/ var - _aX_ = /*<>*/ caml_call1(Stdlib_Domain[10][2], key); + _aY_ = /*<>*/ caml_call1(Stdlib_Domain[10][2], key); /*<>*/ return /*<>*/ caml_call4 - (Stdlib_Buffer[18], _aX_, str, ofs, len); + (Stdlib_Buffer[18], _aY_, str, ofs, len); /*<>*/ } function buffered_out_flush(oc, key, param){ /*<>*/ var @@ -26451,31 +26523,31 @@ err_buf_key = /*<>*/ caml_call2(Stdlib_Domain[10][1], 0, _i_); function _j_(param){ - function _aG_(_aW_){ /*<>*/ return 0;} - function _aH_(_aV_){ /*<>*/ return 0;} - function _aI_(_aU_){ /*<>*/ return 0;} - var _aJ_ = Stdlib[39]; - /*<>*/ function _aK_(_aT_){ - /*<>*/ return buffered_out_flush(_aJ_, std_buf_key, _aT_); + function _aH_(_aX_){ /*<>*/ return 0;} + function _aI_(_aW_){ /*<>*/ return 0;} + function _aJ_(_aV_){ /*<>*/ return 0;} + var _aK_ = Stdlib[39]; + /*<>*/ function _aL_(_aU_){ + /*<>*/ return buffered_out_flush(_aK_, std_buf_key, _aU_); } /*<>*/ /*<>*/ var ppf = pp_make_formatter - (function(_aQ_, _aR_, _aS_){ - /*<>*/ return buffered_out_string(std_buf_key, _aQ_, _aR_, _aS_); + (function(_aR_, _aS_, _aT_){ + /*<>*/ return buffered_out_string(std_buf_key, _aR_, _aS_, _aT_); }, - _aK_, + _aL_, + _aJ_, _aI_, - _aH_, - _aG_); - ppf[19] = function(_aP_){ /*<>*/ return display_newline(ppf, _aP_);}; - ppf[20] = function(_aO_){ /*<>*/ return display_blanks(ppf, _aO_);}; - ppf[21] = function(_aN_){ /*<>*/ return display_blanks(ppf, _aN_);}; - /*<>*/ function _aL_(_aM_){ - /*<>*/ return pp_print_flush(ppf, _aM_); + _aH_); + ppf[19] = function(_aQ_){ /*<>*/ return display_newline(ppf, _aQ_);}; + ppf[20] = function(_aP_){ /*<>*/ return display_blanks(ppf, _aP_);}; + ppf[21] = function(_aO_){ /*<>*/ return display_blanks(ppf, _aO_);}; + /*<>*/ function _aM_(_aN_){ + /*<>*/ return pp_print_flush(ppf, _aN_); } /*<>*/ /*<>*/ caml_call1 - (Stdlib_Domain[6], _aL_); + (Stdlib_Domain[6], _aM_); /*<>*/ return ppf; /*<>*/ } /*<>*/ /*<>*/ var @@ -26484,31 +26556,31 @@ /*<>*/ /*<>*/ caml_call2 (Stdlib_Domain[10][3], std_formatter_key, std_formatter); function _k_(param){ - function _ap_(_aF_){ /*<>*/ return 0;} - function _aq_(_aE_){ /*<>*/ return 0;} - function _ar_(_aD_){ /*<>*/ return 0;} - var _as_ = Stdlib[40]; - /*<>*/ function _at_(_aC_){ - /*<>*/ return buffered_out_flush(_as_, err_buf_key, _aC_); + function _aq_(_aG_){ /*<>*/ return 0;} + function _ar_(_aF_){ /*<>*/ return 0;} + function _as_(_aE_){ /*<>*/ return 0;} + var _at_ = Stdlib[40]; + /*<>*/ function _au_(_aD_){ + /*<>*/ return buffered_out_flush(_at_, err_buf_key, _aD_); } /*<>*/ /*<>*/ var ppf = pp_make_formatter - (function(_az_, _aA_, _aB_){ - /*<>*/ return buffered_out_string(err_buf_key, _az_, _aA_, _aB_); + (function(_aA_, _aB_, _aC_){ + /*<>*/ return buffered_out_string(err_buf_key, _aA_, _aB_, _aC_); }, - _at_, + _au_, + _as_, _ar_, - _aq_, - _ap_); - ppf[19] = function(_ay_){ /*<>*/ return display_newline(ppf, _ay_);}; - ppf[20] = function(_ax_){ /*<>*/ return display_blanks(ppf, _ax_);}; - ppf[21] = function(_aw_){ /*<>*/ return display_blanks(ppf, _aw_);}; - /*<>*/ function _au_(_av_){ - /*<>*/ return pp_print_flush(ppf, _av_); + _aq_); + ppf[19] = function(_az_){ /*<>*/ return display_newline(ppf, _az_);}; + ppf[20] = function(_ay_){ /*<>*/ return display_blanks(ppf, _ay_);}; + ppf[21] = function(_ax_){ /*<>*/ return display_blanks(ppf, _ax_);}; + /*<>*/ function _av_(_aw_){ + /*<>*/ return pp_print_flush(ppf, _aw_); } /*<>*/ /*<>*/ caml_call1 - (Stdlib_Domain[6], _au_); + (Stdlib_Domain[6], _av_); /*<>*/ return ppf; /*<>*/ } /*<>*/ /*<>*/ var @@ -26551,7 +26623,7 @@ (stdbuf, str_formatter); /*<>*/ } function make_synchronized_formatter(output, flush){ - function _an_(param){ + function _ao_(param){ /*<>*/ var /*<>*/ buf = /*<>*/ caml_call1 @@ -26560,12 +26632,12 @@ /*<>*/ caml_call1(Stdlib_Buffer[18], buf); function flush$0(param){ /*<>*/ /*<>*/ var - _ao_ = /*<>*/ caml_call1(Stdlib_Buffer[7], buf); + _ap_ = /*<>*/ caml_call1(Stdlib_Buffer[7], buf); /*<>*/ /*<>*/ caml_call3 (output, /*<>*/ caml_call1(Stdlib_Buffer[2], buf), 0, - _ao_); + _ap_); /*<>*/ /*<>*/ caml_call1 (Stdlib_Buffer[8], buf); /*<>*/ return /*<>*/ caml_call1 @@ -26574,15 +26646,15 @@ /*<>*/ return make_formatter(output$0, flush$0); /*<>*/ } /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Domain[10][1], 0, _an_); + (Stdlib_Domain[10][1], 0, _ao_); /*<>*/ } function synchronized_formatter_of_out_(oc){ - function _am_(param){ + function _an_(param){ /*<>*/ return /*<>*/ caml_call1 (Stdlib[63], oc); /*<>*/ } /*<>*/ return make_synchronized_formatter - ( /*<>*/ caml_call1(Stdlib[69], oc), _am_); + ( /*<>*/ caml_call1(Stdlib[69], oc), _an_); /*<>*/ } function make_symbolic_output_buffer(param){ /*<>*/ return [0, 0]; /*<>*/ } @@ -26611,10 +26683,10 @@ /*<>*/ caml_call3 (Stdlib_String[16], s, i, n)]); } - /*<>*/ function g(_al_){ + /*<>*/ function g(_am_){ /*<>*/ return add_symbolic_output_item(sob, 0); } - /*<>*/ function h(_ak_){ + /*<>*/ function h(_al_){ /*<>*/ return add_symbolic_output_item(sob, 1); } /*<>*/ function i(n){ @@ -26996,8 +27068,8 @@ /*<>*/ } for(;;){ if(right[1] === len){ - var _aj_ = left[1] !== len ? 1 : 0; - return _aj_ ? flush(0) : _aj_; + var _ak_ = left[1] !== len ? 1 : 0; + return _ak_ ? flush(0) : _ak_; } /*<>*/ /*<>*/ var match = /*<>*/ runtime.caml_string_get(s, right[1]); @@ -27019,7 +27091,7 @@ else var none = - function(param, _ai_){ + function(param, _aj_){ /*<>*/ return 0; /*<>*/ }; /*<>*/ if(! param) @@ -27118,56 +27190,56 @@ var acc$1 = match[1]; /*<>*/ output_acc(ppf, p$0); /*<>*/ var - /*<>*/ _$_ = compute_tag(output_acc, acc$1), + /*<>*/ _aa_ = compute_tag(output_acc, acc$1), /*<>*/ match$0 = /*<>*/ caml_call1 - (CamlinternalFormat[20], _$_), + (CamlinternalFormat[20], _aa_), bty = match$0[2], indent = match$0[1]; /*<>*/ return pp_open_box_gen(ppf, indent, bty); case 2: - var _aa_ = acc[1]; - if(typeof _aa_ !== "number" && 0 === _aa_[0]){ - var _ab_ = _aa_[2]; - if(typeof _ab_ !== "number" && 1 === _ab_[0]){ - var s$0 = acc[2], size = _ab_[2], p$2 = _aa_[1]; + var _ab_ = acc[1]; + if(typeof _ab_ !== "number" && 0 === _ab_[0]){ + var _ac_ = _ab_[2]; + if(typeof _ac_ !== "number" && 1 === _ac_[0]){ + var s$0 = acc[2], size = _ac_[2], p$2 = _ab_[1]; break b; } } - var s = acc[2], p$1 = _aa_; + var s = acc[2], p$1 = _ab_; break a; case 3: - var _ac_ = acc[1]; - if(typeof _ac_ !== "number" && 0 === _ac_[0]){ - var _ad_ = _ac_[2]; - if(typeof _ad_ !== "number" && 1 === _ad_[0]){ - var c$0 = acc[2], size$0 = _ad_[2], p$4 = _ac_[1]; + var _ad_ = acc[1]; + if(typeof _ad_ !== "number" && 0 === _ad_[0]){ + var _ae_ = _ad_[2]; + if(typeof _ae_ !== "number" && 1 === _ae_[0]){ + var c$0 = acc[2], size$0 = _ae_[2], p$4 = _ad_[1]; break; } } - var c = acc[2], p$3 = _ac_; + var c = acc[2], p$3 = _ad_; break c; case 4: - var _ae_ = acc[1]; - if(typeof _ae_ !== "number" && 0 === _ae_[0]){ - var _af_ = _ae_[2]; - if(typeof _af_ !== "number" && 1 === _af_[0]){ - var s$0 = acc[2], size = _af_[2], p$2 = _ae_[1]; + var _af_ = acc[1]; + if(typeof _af_ !== "number" && 0 === _af_[0]){ + var _ag_ = _af_[2]; + if(typeof _ag_ !== "number" && 1 === _ag_[0]){ + var s$0 = acc[2], size = _ag_[2], p$2 = _af_[1]; break b; } } - var s = acc[2], p$1 = _ae_; + var s = acc[2], p$1 = _af_; break a; case 5: - var _ag_ = acc[1]; - if(typeof _ag_ !== "number" && 0 === _ag_[0]){ - var _ah_ = _ag_[2]; - if(typeof _ah_ !== "number" && 1 === _ah_[0]){ - var c$0 = acc[2], size$0 = _ah_[2], p$4 = _ag_[1]; + var _ah_ = acc[1]; + if(typeof _ah_ !== "number" && 0 === _ah_[0]){ + var _ai_ = _ah_[2]; + if(typeof _ai_ !== "number" && 1 === _ai_[0]){ + var c$0 = acc[2], size$0 = _ai_[2], p$4 = _ah_[1]; break; } } - var c = acc[2], p$3 = _ag_; + var c = acc[2], p$3 = _ah_; break c; case 6: var f$0 = acc[2], p$5 = acc[1]; @@ -27225,56 +27297,56 @@ var acc$1 = match[1]; /*<>*/ strput_acc(ppf, p$0); /*<>*/ var - /*<>*/ _S_ = compute_tag(strput_acc, acc$1), + /*<>*/ _T_ = compute_tag(strput_acc, acc$1), /*<>*/ match$0 = /*<>*/ caml_call1 - (CamlinternalFormat[20], _S_), + (CamlinternalFormat[20], _T_), bty = match$0[2], indent = match$0[1]; /*<>*/ return pp_open_box_gen(ppf, indent, bty); case 2: - var _T_ = acc[1]; - if(typeof _T_ !== "number" && 0 === _T_[0]){ - var _U_ = _T_[2]; - if(typeof _U_ !== "number" && 1 === _U_[0]){ - var s$0 = acc[2], size = _U_[2], p$2 = _T_[1]; + var _U_ = acc[1]; + if(typeof _U_ !== "number" && 0 === _U_[0]){ + var _V_ = _U_[2]; + if(typeof _V_ !== "number" && 1 === _V_[0]){ + var s$0 = acc[2], size = _V_[2], p$2 = _U_[1]; break b; } } - var s = acc[2], p$1 = _T_; + var s = acc[2], p$1 = _U_; break a; case 3: - var _V_ = acc[1]; - if(typeof _V_ !== "number" && 0 === _V_[0]){ - var _W_ = _V_[2]; - if(typeof _W_ !== "number" && 1 === _W_[0]){ - var c$0 = acc[2], size$0 = _W_[2], p$4 = _V_[1]; + var _W_ = acc[1]; + if(typeof _W_ !== "number" && 0 === _W_[0]){ + var _X_ = _W_[2]; + if(typeof _X_ !== "number" && 1 === _X_[0]){ + var c$0 = acc[2], size$0 = _X_[2], p$4 = _W_[1]; break; } } - var c = acc[2], p$3 = _V_; + var c = acc[2], p$3 = _W_; break c; case 4: - var _X_ = acc[1]; - if(typeof _X_ !== "number" && 0 === _X_[0]){ - var _Y_ = _X_[2]; - if(typeof _Y_ !== "number" && 1 === _Y_[0]){ - var s$0 = acc[2], size = _Y_[2], p$2 = _X_[1]; + var _Y_ = acc[1]; + if(typeof _Y_ !== "number" && 0 === _Y_[0]){ + var _Z_ = _Y_[2]; + if(typeof _Z_ !== "number" && 1 === _Z_[0]){ + var s$0 = acc[2], size = _Z_[2], p$2 = _Y_[1]; break b; } } - var s = acc[2], p$1 = _X_; + var s = acc[2], p$1 = _Y_; break a; case 5: - var _Z_ = acc[1]; - if(typeof _Z_ !== "number" && 0 === _Z_[0]){ - var ___ = _Z_[2]; - if(typeof ___ !== "number" && 1 === ___[0]){ - var c$0 = acc[2], size$0 = ___[2], p$4 = _Z_[1]; + var ___ = acc[1]; + if(typeof ___ !== "number" && 0 === ___[0]){ + var _$_ = ___[2]; + if(typeof _$_ !== "number" && 1 === _$_[0]){ + var c$0 = acc[2], size$0 = _$_[2], p$4 = ___[1]; break; } } - var c = acc[2], p$3 = _Z_; + var c = acc[2], p$3 = ___; break c; case 6: var p$5 = acc[1]; @@ -27320,13 +27392,13 @@ function kfprintf(k, ppf, param){ /*<>*/ var fmt = param[1], - /*<>*/ _Q_ = 0; - function _R_(acc){ + /*<>*/ _R_ = 0; + function _S_(acc){ /*<>*/ output_acc(ppf, acc); return caml_call1(k, ppf); /*<>*/ } /*<>*/ return /*<>*/ caml_call3 - (CamlinternalFormat[7], _R_, _Q_, fmt); + (CamlinternalFormat[7], _S_, _R_, fmt); } function ikfprintf(k, ppf, param){ var fmt = param[1]; @@ -27336,47 +27408,47 @@ function ifprintf(ppf, param){ /*<>*/ var fmt = param[1], - /*<>*/ _N_ = 0; - function _O_(_P_){ /*<>*/ return 0;} + /*<>*/ _O_ = 0; + function _P_(_Q_){ /*<>*/ return 0;} /*<>*/ return /*<>*/ caml_call3 - (CamlinternalFormat[8], _O_, _N_, fmt); + (CamlinternalFormat[8], _P_, _O_, fmt); } function fprintf(ppf){ - function _K_(_M_){ /*<>*/ return 0;} - /*<>*/ return function(_L_){ - /*<>*/ return kfprintf(_K_, ppf, _L_);}; + function _L_(_N_){ /*<>*/ return 0;} + /*<>*/ return function(_M_){ + /*<>*/ return kfprintf(_L_, ppf, _M_);}; /*<>*/ } function printf(param){ /*<>*/ var fmt = param[1], - /*<>*/ _I_ = 0; - function _J_(acc){ + /*<>*/ _J_ = 0; + function _K_(acc){ /*<>*/ return output_acc ( /*<>*/ caml_call1 (Stdlib_Domain[10][2], std_formatter_key), acc); /*<>*/ } /*<>*/ return /*<>*/ caml_call3 - (CamlinternalFormat[7], _J_, _I_, fmt); + (CamlinternalFormat[7], _K_, _J_, fmt); } function eprintf(param){ /*<>*/ var fmt = param[1], - /*<>*/ _G_ = 0; - function _H_(acc){ + /*<>*/ _H_ = 0; + function _I_(acc){ /*<>*/ return output_acc ( /*<>*/ caml_call1 (Stdlib_Domain[10][2], err_formatter_key), acc); /*<>*/ } /*<>*/ return /*<>*/ caml_call3 - (CamlinternalFormat[7], _H_, _G_, fmt); + (CamlinternalFormat[7], _I_, _H_, fmt); } function kdprintf(k, param){ /*<>*/ var fmt = param[1], - /*<>*/ _E_ = 0; - function _F_(acc){ + /*<>*/ _F_ = 0; + function _G_(acc){ /*<>*/ return /*<>*/ caml_call1 (k, function(ppf){ @@ -27384,7 +27456,7 @@ /*<>*/ }); /*<>*/ } /*<>*/ return /*<>*/ caml_call3 - (CamlinternalFormat[7], _F_, _E_, fmt); + (CamlinternalFormat[7], _G_, _F_, fmt); } function dprintf(fmt){ /*<>*/ return kdprintf @@ -27442,44 +27514,44 @@ /*<>*/ var /*<>*/ fs = pp_get_formatter_out_functions(std_formatter, 0), - _m_ = fs[5], - _n_ = fs[4], - _o_ = fs[3], - _p_ = Stdlib[39]; - /*<>*/ function _q_(_D_){ - /*<>*/ return buffered_out_flush(_p_, std_buf_key, _D_); + _n_ = fs[5], + _o_ = fs[4], + _p_ = fs[3], + _q_ = Stdlib[39]; + /*<>*/ function _r_(_E_){ + /*<>*/ return buffered_out_flush(_q_, std_buf_key, _E_); } /*<>*/ pp_set_formatter_out_functions (std_formatter, [0, - function(_A_, _B_, _C_){ - /*<>*/ return buffered_out_string(std_buf_key, _A_, _B_, _C_); + function(_B_, _C_, _D_){ + /*<>*/ return buffered_out_string(std_buf_key, _B_, _C_, _D_); }, - _q_, + _r_, + _p_, _o_, - _n_, - _m_]); + _n_]); /*<>*/ var /*<>*/ fs$0 = pp_get_formatter_out_functions(err_formatter, 0), - _r_ = fs$0[5], - _s_ = fs$0[4], - _t_ = fs$0[3], - _u_ = Stdlib[40]; - /*<>*/ function _v_(_z_){ - /*<>*/ return buffered_out_flush(_u_, err_buf_key, _z_); + _s_ = fs$0[5], + _t_ = fs$0[4], + _u_ = fs$0[3], + _v_ = Stdlib[40]; + /*<>*/ function _w_(_A_){ + /*<>*/ return buffered_out_flush(_v_, err_buf_key, _A_); } /*<>*/ return pp_set_formatter_out_functions (err_formatter, [0, - function(_w_, _x_, _y_){ + function(_x_, _y_, _z_){ /*<>*/ return buffered_out_string - (err_buf_key, _w_, _x_, _y_); + (err_buf_key, _x_, _y_, _z_); }, - _v_, + _w_, + _u_, _t_, - _s_, - _r_]); + _s_]); /*<>*/ } /*<>*/ /*<>*/ caml_call1 (Stdlib_Domain[5], _l_); @@ -27682,6 +27754,7 @@ : runtime.caml_call_gen(f, [a0, a1, a2, a3]); } var + _u_ = undefined, global_data = runtime.caml_get_global_data(), cst$3 = cst$5, cst$4 = cst$5, @@ -27805,9 +27878,9 @@ if(10 === c) ib[5] = ib[5] + 1 | 0; /*<>*/ return c; } - catch(_bb_){ - var _ba_ = caml_wrap_exception(_bb_); - if(_ba_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_ba_, 0); + catch(_bc_){ + var _bb_ = caml_wrap_exception(_bc_); + if(_bb_ !== Stdlib[12]) throw caml_maybe_attach_backtrace(_bb_, 0); ib[2] = null_char; ib[3] = 0; ib[1] = 1; @@ -27900,8 +27973,8 @@ /*<>*/ return create(1, next); /*<>*/ } var _a_ = 0; - /*<>*/ function from_function(_a$_){ - /*<>*/ return create(_a_, _a$_); + /*<>*/ function from_function(_ba_){ + /*<>*/ return create(_a_, _ba_); } /*<>*/ /*<>*/ var len = 1024; function scan_close_at_end(ic){ @@ -27948,12 +28021,12 @@ return from_ic(scan_close_at_end, [1, fname, ic], ic); /*<>*/ } var _b_ = Stdlib[79]; - /*<>*/ function open_in(_a__){ - /*<>*/ return open_in_file(_b_, _a__); + /*<>*/ function open_in(_a$_){ + /*<>*/ return open_in_file(_b_, _a$_); } /*<>*/ /*<>*/ var _c_ = Stdlib[80]; - /*<>*/ function open_in_bin(_a9_){ - /*<>*/ return open_in_file(_c_, _a9_); + /*<>*/ function open_in_bin(_a__){ + /*<>*/ return open_in_file(_c_, _a__); } function from_channel(ic){ /*<>*/ return from_ic(scan_raise_at_end, [0, ic], ic); @@ -28016,15 +28089,15 @@ /*<>*/ for(;;){ /*<>*/ var /*<>*/ c = peek_char(ib), - /*<>*/ _a7_ = 1 - ib[1]; - if(! _a7_) /*<>*/ return _a7_; - /*<>*/ /*<>*/ var _a8_ = c - 9 | 0; + /*<>*/ _a8_ = 1 - ib[1]; + if(! _a8_) /*<>*/ return _a8_; + /*<>*/ /*<>*/ var _a9_ = c - 9 | 0; a: { - if(4 < _a8_ >>> 0){ - if(23 === _a8_) break a; + if(4 < _a9_ >>> 0){ + if(23 === _a9_) break a; } - else if(1 < _a8_ - 2 >>> 0) break a; + else if(1 < _a9_ - 2 >>> 0) break a; /*<>*/ return 0; } /*<>*/ invalidate_current_char(ib); @@ -28070,23 +28143,23 @@ /*<>*/ switch(conv){ case 0: /*<>*/ var - /*<>*/ _a3_ = token_string(ib), - tok = /*<>*/ caml_call2(Stdlib[28], cst_0b, _a3_); + /*<>*/ _a4_ = token_string(ib), + tok = /*<>*/ caml_call2(Stdlib[28], cst_0b, _a4_); break; case 3: /*<>*/ var - /*<>*/ _a4_ = token_string(ib), - tok = /*<>*/ caml_call2(Stdlib[28], cst_0o, _a4_); + /*<>*/ _a5_ = token_string(ib), + tok = /*<>*/ caml_call2(Stdlib[28], cst_0o, _a5_); break; case 4: /*<>*/ var - /*<>*/ _a5_ = token_string(ib), - tok = /*<>*/ caml_call2(Stdlib[28], cst_0u, _a5_); + /*<>*/ _a6_ = token_string(ib), + tok = /*<>*/ caml_call2(Stdlib[28], cst_0u, _a6_); break; case 5: /*<>*/ var - /*<>*/ _a6_ = token_string(ib), - tok = /*<>*/ caml_call2(Stdlib[28], cst_0x, _a6_); + /*<>*/ _a7_ = token_string(ib), + tok = /*<>*/ caml_call2(Stdlib[28], cst_0x, _a7_); break; default: var tok = token_string(ib); } @@ -28171,31 +28244,31 @@ function is_binary_digit(param){ /*<>*/ return 1 < param - 48 >>> 0 ? 0 : 1; /*<>*/ } - /*<>*/ function scan_binary_int(_a1_, _a2_){ - /*<>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a1_, _a2_); + /*<>*/ function scan_binary_int(_a2_, _a3_){ + /*<>*/ return scan_digit_plus(cst_binary, is_binary_digit, _a2_, _a3_); } function is_octal_digit(param){ /*<>*/ return 7 < param - 48 >>> 0 ? 0 : 1; /*<>*/ } - /*<>*/ function scan_octal_int(_aZ_, _a0_){ - /*<>*/ return scan_digit_plus(cst_octal, is_octal_digit, _aZ_, _a0_); + /*<>*/ function scan_octal_int(_a0_, _a1_){ + /*<>*/ return scan_digit_plus(cst_octal, is_octal_digit, _a0_, _a1_); } function is_hexa_digit(param){ /*<>*/ /*<>*/ var - _aY_ = param - 48 | 0; + _aZ_ = param - 48 | 0; a: { - if(22 < _aY_ >>> 0){ - if(5 < _aY_ - 49 >>> 0) break a; + if(22 < _aZ_ >>> 0){ + if(5 < _aZ_ - 49 >>> 0) break a; } - else if(6 >= _aY_ - 10 >>> 0) break a; + else if(6 >= _aZ_ - 10 >>> 0) break a; /*<>*/ return 1; } /*<>*/ return 0; /*<>*/ } - /*<>*/ function scan_hexadecimal_int(_aW_, _aX_){ + /*<>*/ function scan_hexadecimal_int(_aX_, _aY_){ /*<>*/ return scan_digit_plus - (cst_hexadecimal, is_hexa_digit, _aW_, _aX_); + (cst_hexadecimal, is_hexa_digit, _aX_, _aY_); } function scan_sign(width, ib){ /*<>*/ var @@ -28315,38 +28388,38 @@ /*<>*/ len = /*<>*/ caml_ml_string_length(str), /*<>*/ width$0 = [0, width], - /*<>*/ _aT_ = len - 1 | 0, - /*<>*/ _aS_ = 0; - if(_aT_ >= 0){ - var i = _aS_; + /*<>*/ _aU_ = len - 1 | 0, + /*<>*/ _aT_ = 0; + if(_aU_ >= 0){ + var i = _aT_; for(;;){ /*<>*/ var /*<>*/ c = peek_char(ib), - /*<>*/ _aU_ = + /*<>*/ _aV_ = lowercase( /*<>*/ caml_string_get(str, i)); - if(lowercase(c) !== _aU_) + if(lowercase(c) !== _aV_) /*<>*/ /*<>*/ caml_call1(error, 0); if(0 === width$0[1]) /*<>*/ /*<>*/ caml_call1(error, 0); width$0[1] = store_char(width$0[1], ib, c); - /*<>*/ /*<>*/ var _aV_ = i + 1 | 0; - if(_aT_ === i) break; - var i = _aV_; + /*<>*/ /*<>*/ var _aW_ = i + 1 | 0; + if(_aU_ === i) break; + var i = _aW_; } } return width$0[1]; /*<>*/ } function scan_hex_float(width, precision, ib){ /*<>*/ var - _aF_ = 0 === width ? 1 : 0, - _aG_ = _aF_ || end_of_input(ib); - /*<>*/ if(_aG_) + _aG_ = 0 === width ? 1 : 0, + _aH_ = _aG_ || end_of_input(ib); + /*<>*/ if(_aH_) /*<>*/ bad_hex_float(0); /*<>*/ var /*<>*/ width$0 = scan_sign(width, ib), - _aH_ = 0 === width$0 ? 1 : 0, - _aI_ = _aH_ || end_of_input(ib); - /*<>*/ if(_aI_) + _aI_ = 0 === width$0 ? 1 : 0, + _aJ_ = _aI_ || end_of_input(ib); + /*<>*/ if(_aJ_) /*<>*/ bad_hex_float(0); /*<>*/ /*<>*/ var c = peek_char(ib); a: @@ -28358,9 +28431,9 @@ if(32 <= switcher) break a; /*<>*/ var /*<>*/ width$1 = store_char(width$0, ib, c), - _aJ_ = 0 === width$1 ? 1 : 0, - _aK_ = _aJ_ || end_of_input(ib); - /*<>*/ if(_aK_) + _aK_ = 0 === width$1 ? 1 : 0, + _aL_ = _aK_ || end_of_input(ib); + /*<>*/ if(_aL_) /*<>*/ bad_hex_float(0); /*<>*/ return check_case_insensitive_string (width$1, ib, bad_hex_float, cst_an); @@ -28371,24 +28444,24 @@ if(48 === c){ /*<>*/ var /*<>*/ width$3 = store_char(width$0, ib, c), - _aN_ = 0 === width$3 ? 1 : 0, - _aO_ = _aN_ || end_of_input(ib); - /*<>*/ if(_aO_) + _aO_ = 0 === width$3 ? 1 : 0, + _aP_ = _aO_ || end_of_input(ib); + /*<>*/ if(_aP_) /*<>*/ bad_hex_float(0); /*<>*/ /*<>*/ var width$4 = check_case_insensitive_string(width$3, ib, bad_hex_float, cst_x); /*<>*/ if(0 !== width$4 && ! end_of_input(ib)){ /*<>*/ /*<>*/ var - _aP_ = peek_char(ib) - 46 | 0; + _aQ_ = peek_char(ib) - 46 | 0; b: { c: { - if(34 < _aP_ >>> 0){ - if(66 === _aP_) break c; + if(34 < _aQ_ >>> 0){ + if(66 === _aQ_) break c; } - else if(32 < _aP_ - 1 >>> 0) break c; + else if(32 < _aQ_ - 1 >>> 0) break c; var width$5 = scan_hexadecimal_int(width$4, ib); break b; } @@ -28436,9 +28509,9 @@ /*<>*/ return width$8; /*<>*/ var /*<>*/ width$9 = store_char(width$8, ib, c$1), - _aQ_ = 0 === width$9 ? 1 : 0, - _aR_ = _aQ_ || end_of_input(ib); - /*<>*/ if(_aR_) + _aR_ = 0 === width$9 ? 1 : 0, + _aS_ = _aR_ || end_of_input(ib); + /*<>*/ if(_aS_) /*<>*/ bad_hex_float(0); /*<>*/ return scan_optionally_signed_decimal (width$9, ib); @@ -28453,9 +28526,9 @@ } /*<>*/ var /*<>*/ width$2 = store_char(width$0, ib, c), - _aL_ = 0 === width$2 ? 1 : 0, - _aM_ = _aL_ || end_of_input(ib); - /*<>*/ if(_aM_) + _aM_ = 0 === width$2 ? 1 : 0, + _aN_ = _aM_ || end_of_input(ib); + /*<>*/ if(_aN_) /*<>*/ bad_hex_float(0); /*<>*/ return check_case_insensitive_string (width$2, ib, bad_hex_float, cst_nfinity); @@ -28464,14 +28537,14 @@ /*<>*/ } function scan_caml_float_rest(width, precision, ib){ /*<>*/ var - _aB_ = 0 === width ? 1 : 0, - _aC_ = _aB_ || end_of_input(ib); - /*<>*/ if(_aC_) /*<>*/ bad_float(0); + _aC_ = 0 === width ? 1 : 0, + _aD_ = _aC_ || end_of_input(ib); + /*<>*/ if(_aD_) /*<>*/ bad_float(0); /*<>*/ var /*<>*/ width$0 = scan_decimal_digit_star(width, ib), - _aD_ = 0 === width$0 ? 1 : 0, - _aE_ = _aD_ || end_of_input(ib); - /*<>*/ if(_aE_) /*<>*/ bad_float(0); + _aE_ = 0 === width$0 ? 1 : 0, + _aF_ = _aE_ || end_of_input(ib); + /*<>*/ if(_aF_) /*<>*/ bad_float(0); /*<>*/ var /*<>*/ c = peek_char(ib), /*<>*/ switcher = c - 69 | 0; @@ -28495,22 +28568,22 @@ /*<>*/ } function scan_caml_float(width, precision, ib){ /*<>*/ var - _an_ = 0 === width ? 1 : 0, - _ao_ = _an_ || end_of_input(ib); - /*<>*/ if(_ao_) /*<>*/ bad_float(0); + _ao_ = 0 === width ? 1 : 0, + _ap_ = _ao_ || end_of_input(ib); + /*<>*/ if(_ap_) /*<>*/ bad_float(0); /*<>*/ var /*<>*/ width$0 = scan_sign(width, ib), - _ap_ = 0 === width$0 ? 1 : 0, - _aq_ = _ap_ || end_of_input(ib); - /*<>*/ if(_aq_) /*<>*/ bad_float(0); + _aq_ = 0 === width$0 ? 1 : 0, + _ar_ = _aq_ || end_of_input(ib); + /*<>*/ if(_ar_) /*<>*/ bad_float(0); /*<>*/ /*<>*/ var c = peek_char(ib); if(49 <= c){ if(58 > c){ /*<>*/ var /*<>*/ width$1 = store_char(width$0, ib, c), - _ar_ = 0 === width$1 ? 1 : 0, - _as_ = _ar_ || end_of_input(ib); - /*<>*/ if(_as_) /*<>*/ bad_float(0); + _as_ = 0 === width$1 ? 1 : 0, + _at_ = _as_ || end_of_input(ib); + /*<>*/ if(_at_) /*<>*/ bad_float(0); /*<>*/ return scan_caml_float_rest (width$1, precision, ib); } @@ -28518,9 +28591,9 @@ else if(48 <= c){ /*<>*/ var /*<>*/ width$2 = store_char(width$0, ib, c), - _at_ = 0 === width$2 ? 1 : 0, - _au_ = _at_ || end_of_input(ib); - /*<>*/ if(_au_) /*<>*/ bad_float(0); + _au_ = 0 === width$2 ? 1 : 0, + _av_ = _au_ || end_of_input(ib); + /*<>*/ if(_av_) /*<>*/ bad_float(0); /*<>*/ /*<>*/ var c$0 = peek_char(ib); if(88 !== c$0 && 120 !== c$0) @@ -28528,14 +28601,14 @@ (width$2, precision, ib); /*<>*/ var /*<>*/ width$3 = store_char(width$2, ib, c$0), - _av_ = 0 === width$3 ? 1 : 0, - _aw_ = _av_ || end_of_input(ib); - /*<>*/ if(_aw_) /*<>*/ bad_float(0); + _aw_ = 0 === width$3 ? 1 : 0, + _ax_ = _aw_ || end_of_input(ib); + /*<>*/ if(_ax_) /*<>*/ bad_float(0); /*<>*/ var /*<>*/ width$4 = scan_hexadecimal_int(width$3, ib), - _ax_ = 0 === width$4 ? 1 : 0, - _ay_ = _ax_ || end_of_input(ib); - /*<>*/ if(_ay_) /*<>*/ bad_float(0); + _ay_ = 0 === width$4 ? 1 : 0, + _az_ = _ay_ || end_of_input(ib); + /*<>*/ if(_az_) /*<>*/ bad_float(0); /*<>*/ var /*<>*/ c$1 = peek_char(ib), /*<>*/ switcher = c$1 - 80 | 0; @@ -28588,9 +28661,9 @@ if(80 !== c$2 && 112 !== c$2) /*<>*/ return width$8; /*<>*/ var /*<>*/ width$9 = store_char(width$8, ib, c$2), - _az_ = 0 === width$9 ? 1 : 0, - _aA_ = _az_ || end_of_input(ib); - /*<>*/ if(_aA_) + _aA_ = 0 === width$9 ? 1 : 0, + _aB_ = _aA_ || end_of_input(ib); + /*<>*/ if(_aB_) /*<>*/ bad_hex_float(0); /*<>*/ return scan_optionally_signed_decimal (width$9, ib); @@ -28607,13 +28680,13 @@ /*<>*/ if(ib[1]) /*<>*/ return width$0; if(! stp){ - /*<>*/ /*<>*/ var _am_ = c - 9 | 0; + /*<>*/ /*<>*/ var _an_ = c - 9 | 0; a: { - if(4 < _am_ >>> 0){ - if(23 === _am_) break a; + if(4 < _an_ >>> 0){ + if(23 === _an_) break a; } - else if(1 < _am_ - 2 >>> 0) break a; + else if(1 < _an_ - 2 >>> 0) break a; /*<>*/ var /*<>*/ width$2 = store_char(width$0, ib, c), width$0 = width$2; @@ -28643,11 +28716,11 @@ (Stdlib_Printf[4], _f_, message)) : c; /*<>*/ } - /*<>*/ function check_next_char_for_char(_ak_, _al_){ - /*<>*/ return check_next_char(cst_a_Char, _ak_, _al_); + /*<>*/ function check_next_char_for_char(_al_, _am_){ + /*<>*/ return check_next_char(cst_a_Char, _al_, _am_); } - /*<>*/ function check_next_char_for_string(_ai_, _aj_){ - /*<>*/ return check_next_char(cst_a_String, _ai_, _aj_); + /*<>*/ function check_next_char_for_string(_aj_, _ak_){ + /*<>*/ return check_next_char(cst_a_String, _aj_, _ak_); } function scan_backslash_char(width, ib){ /*<>*/ /*<>*/ var @@ -28673,16 +28746,16 @@ b: { if(0 <= c && 255 >= c){ - var _ag_ = /*<>*/ caml_call1(Stdlib[29], c); + var _ah_ = /*<>*/ caml_call1(Stdlib[29], c); break b; } var - _ag_ = + _ah_ = bad_input ( /*<>*/ caml_call4 (Stdlib_Printf[4], _l_, c0, c1$0, c2$0)); } - /*<>*/ return store_char(width - 2 | 0, ib, _ag_); + /*<>*/ return store_char(width - 2 | 0, ib, _ah_); } /*<>*/ /*<>*/ var switcher = c0 - 92 | 0; @@ -28694,34 +28767,34 @@ function(param){ /*<>*/ var /*<>*/ c = next_char(ib), - /*<>*/ _ah_ = c - 48 | 0; + /*<>*/ _ai_ = c - 48 | 0; a: { - if(22 < _ah_ >>> 0){ - if(5 < _ah_ - 49 >>> 0) break a; + if(22 < _ai_ >>> 0){ + if(5 < _ai_ - 49 >>> 0) break a; } - else if(6 >= _ah_ - 10 >>> 0) break a; + else if(6 >= _ai_ - 10 >>> 0) break a; /*<>*/ return c; } /*<>*/ return bad_input_escape(c); /*<>*/ }, /*<>*/ c1 = get_digit(0), /*<>*/ c2 = get_digit(0), - /*<>*/ _ad_ = hexadecimal_value_of_char(c2), - c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ad_ | 0; + /*<>*/ _ae_ = hexadecimal_value_of_char(c2), + c$0 = (16 * hexadecimal_value_of_char(c1) | 0) + _ae_ | 0; b: { if(0 <= c$0 && 255 >= c$0){ - var _af_ = /*<>*/ caml_call1(Stdlib[29], c$0); + var _ag_ = /*<>*/ caml_call1(Stdlib[29], c$0); break b; } var - _af_ = + _ag_ = bad_input ( /*<>*/ caml_call3 (Stdlib_Printf[4], _m_, c1, c2)); } - /*<>*/ return store_char(width - 2 | 0, ib, _af_); + /*<>*/ return store_char(width - 2 | 0, ib, _ag_); case 0: case 6: case 18: @@ -28737,17 +28810,17 @@ if(117 > c0) switch(c0 - 110 | 0){ case 0: - var _ae_ = 10; break b; + var _af_ = 10; break b; case 4: - var _ae_ = 13; break b; + var _af_ = 13; break b; case 6: - var _ae_ = 9; break b; + var _af_ = 9; break b; } } - else if(98 === c0){var _ae_ = 8; break b;} - var _ae_ = c0; + else if(98 === c0){var _af_ = 8; break b;} + var _af_ = c0; } - /*<>*/ return store_char(width, ib, _ae_); + /*<>*/ return store_char(width, ib, _af_); } /*<>*/ return bad_input_escape(c0); /*<>*/ } @@ -28765,24 +28838,24 @@ check_next_char_for_string(width$1, ib); if(10 === match){ /*<>*/ /*<>*/ var - _ab_ = ignore_char(width$1, ib); + _ac_ = ignore_char(width$1, ib); /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return - (skip_spaces, [0, _ab_]); + (skip_spaces, [0, _ac_]); var counter$0 = counter + 1 | 0; - /*<>*/ return skip_spaces(counter$0, _ab_); + /*<>*/ return skip_spaces(counter$0, _ac_); } if(13 === match){ /*<>*/ /*<>*/ var width$3 = ignore_char(width$1, ib); if(10 === check_next_char_for_string(width$3, ib)){ /*<>*/ /*<>*/ var - _ac_ = ignore_char(width$3, ib); + _ad_ = ignore_char(width$3, ib); /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return - (skip_spaces, [0, _ac_]); + (skip_spaces, [0, _ad_]); var counter$1 = counter + 1 | 0; - /*<>*/ return skip_spaces(counter$1, _ac_); + /*<>*/ return skip_spaces(counter$1, _ad_); } /*<>*/ var /*<>*/ width$5 = store_char(width$3, ib, 13), @@ -28829,34 +28902,42 @@ /*<>*/ for(;;){ /*<>*/ var /*<>*/ c = peek_char(ib), - _Z_ = 0 < i$0 ? 1 : 0; - if(_Z_){ + ___ = 0 < i$0 ? 1 : 0; + if(___){ /*<>*/ /*<>*/ var - ___ = 1 - ib[1]; - if(___) + _$_ = 1 - ib[1]; + if(_$_) /*<>*/ var - /*<>*/ _$_ = + /*<>*/ _aa_ = /*<>*/ caml_call2 (CamlinternalFormat[1], char_set, c), - /*<>*/ _aa_ = _$_ ? c !== stp ? 1 : 0 : _$_; + /*<>*/ _ab_ = _aa_ ? c !== stp ? 1 : 0 : _aa_; else - var _aa_ = ___; + var _ab_ = _$_; } else - var _aa_ = _Z_; - if(! _aa_) return _aa_; + var _ab_ = ___; + if(! _ab_) return _ab_; /*<>*/ store_char(Stdlib[19], ib, c); var i$1 = i$0 - 1 | 0, i$0 = i$1; } /*<>*/ } - if(! scan_indic) /*<>*/ return scan_chars(width, -1); + if(! scan_indic){ + /*<>*/ scan_chars(width, -1); + /*<>*/ return; + } var c = scan_indic[1]; /*<>*/ scan_chars(width, c); - /*<>*/ /*<>*/ var _Y_ = 1 - ib[1]; - if(! _Y_) /*<>*/ return _Y_; + /*<>*/ /*<>*/ var _Z_ = 1 - ib[1]; + if(! _Z_) /*<>*/ return _Z_; /*<>*/ /*<>*/ var ci = peek_char(ib); - return c === ci ? invalidate_current_char(ib) : character_mismatch(c, ci); + if(c === ci){ + /*<>*/ invalidate_current_char(ib); + /*<>*/ return; + } + /*<>*/ character_mismatch(c, ci); + /*<>*/ return; /*<>*/ } function scanf_bad_input(ib, x){ /*<>*/ if(x[1] === Scan_failure) @@ -28933,17 +29014,17 @@ /*<>*/ var rest$13 = fmt$0[3], fmtty = fmt$0[2], - /*<>*/ _V_ = + /*<>*/ _W_ = /*<>*/ caml_call1(CamlinternalFormat[21], fmtty), - /*<>*/ _W_ = + /*<>*/ _X_ = /*<>*/ caml_call1 - (CamlinternalFormatBasics[2], _V_); + (CamlinternalFormatBasics[2], _W_); /*<>*/ if(counter >= 50) /*<>*/ return /*<>*/ caml_trampoline_return - (take_fmtty_format_readers$0, [0, k, _W_, rest$13]); + (take_fmtty_format_readers$0, [0, k, _X_, rest$13]); var counter$0 = counter + 1 | 0; /*<>*/ return take_fmtty_format_readers$0 - (counter$0, k, _W_, rest$13); + (counter$0, k, _X_, rest$13); case 15: var rest$14 = fmt$0[1], fmt$0 = rest$14; break; case 16: @@ -28951,11 +29032,11 @@ case 17: var rest$16 = fmt$0[2], fmt$0 = rest$16; break; case 18: - var _X_ = fmt$0[1]; - if(0 === _X_[0]) + var _Y_ = fmt$0[1]; + if(0 === _Y_[0]) /*<>*/ var rest$17 = fmt$0[2], - fmt$1 = _X_[1][1], + fmt$1 = _Y_[1][1], /*<>*/ fmt$2 = /*<>*/ caml_call2 (CamlinternalFormatBasics[3], fmt$1, rest$17), @@ -28963,7 +29044,7 @@ else /*<>*/ var rest$18 = fmt$0[2], - fmt$3 = _X_[1][1], + fmt$3 = _Y_[1][1], /*<>*/ fmt$4 = /*<>*/ caml_call2 (CamlinternalFormatBasics[3], fmt$3, rest$18), @@ -29073,11 +29154,11 @@ rest = fmtty$0[3], ty2 = fmtty$0[2], ty1 = fmtty$0[1], - /*<>*/ _U_ = + /*<>*/ _V_ = /*<>*/ caml_call1(CamlinternalFormat[21], ty1), /*<>*/ ty = /*<>*/ caml_call2 - (CamlinternalFormat[22], _U_, ty2), + (CamlinternalFormat[22], _V_, ty2), /*<>*/ fmtty$10 = /*<>*/ caml_call2 (CamlinternalFormatBasics[1], ty, rest), @@ -29181,9 +29262,12 @@ function(width){ /*<>*/ /*<>*/ var c = check_next_char_for_char(width, ib); - return 39 === c - ? ignore_char(width, ib) - : character_mismatch(39, c); + if(39 === c){ + /*<>*/ ignore_char(width, ib); + /*<>*/ return; + } + /*<>*/ character_mismatch(39, c); + /*<>*/ return; /*<>*/ }, /*<>*/ c = checked_peek_char(ib); if(39 === c){ @@ -29224,11 +29308,11 @@ /*<>*/ return pad_prec_scanf (ib, str_rest, readers, pad, 0, scan$0, token_string); case 18: - var _G_ = match[1]; - if(0 === _G_[0]){ + var _H_ = match[1]; + if(0 === _H_[0]){ /*<>*/ var rest$3 = match[2], - fmt$1 = _G_[1][1], + fmt$1 = _H_[1][1], /*<>*/ scan$1 = function(width, param, ib){ /*<>*/ return scan_string(_q_, width, ib); @@ -29245,7 +29329,7 @@ } /*<>*/ var rest$4 = match[2], - fmt$2 = _G_[1][1], + fmt$2 = _H_[1][1], /*<>*/ scan$2 = function(width, param, ib){ /*<>*/ return scan_string(_r_, width, ib); @@ -29422,7 +29506,7 @@ rest$13 = fmt$0[2], pad$8 = fmt$0[1], /*<>*/ scan$8 = - function(param, _T_, ib){ + function(param, _U_, ib){ /*<>*/ var /*<>*/ c = checked_peek_char(ib), /*<>*/ m = @@ -29448,10 +29532,10 @@ /*<>*/ var rest$15 = fmt$0[2], str$0 = fmt$0[1], - /*<>*/ _H_ = - function(_S_){ /*<>*/ return check_char(ib, _S_);}; + /*<>*/ _I_ = + function(_T_){ /*<>*/ return check_char(ib, _T_);}; /*<>*/ /*<>*/ caml_call2 - (Stdlib_String[30], _H_, str$0); + (Stdlib_String[30], _I_, str$0); var fmt$0 = rest$15; break; case 12: @@ -29467,10 +29551,10 @@ s = token_string(ib); /*<>*/ try{ /*<>*/ var - /*<>*/ _I_ = + /*<>*/ _J_ = /*<>*/ caml_call2 (CamlinternalFormat[14], s, fmtty), - fmt$3 = _I_; + fmt$3 = _J_; } catch(exn$0){ var exn = caml_wrap_exception(exn$0); @@ -29496,23 +29580,23 @@ /*<>*/ caml_call2 (CamlinternalFormat[13], 0, s$0) [1], - /*<>*/ _K_ = + /*<>*/ _L_ = /*<>*/ caml_call1 (CamlinternalFormat[21], fmtty$0), - /*<>*/ _L_ = + /*<>*/ _M_ = /*<>*/ caml_call1 - (CamlinternalFormatBasics[2], _K_), + (CamlinternalFormatBasics[2], _L_), /*<>*/ fmt$8 = /*<>*/ caml_call2 - (CamlinternalFormat[12], fmt$7, _L_), - /*<>*/ _M_ = + (CamlinternalFormat[12], fmt$7, _M_), + /*<>*/ _N_ = /*<>*/ caml_call1 (CamlinternalFormatBasics[2], fmtty$0), - /*<>*/ _N_ = + /*<>*/ _O_ = /*<>*/ caml_call2 - (CamlinternalFormat[12], fmt$6, _M_), + (CamlinternalFormat[12], fmt$6, _N_), fmt$5 = fmt$8, - fmt$4 = _N_; + fmt$4 = _O_; } catch(exn){ var exn$0 = caml_wrap_exception(exn); @@ -29520,9 +29604,9 @@ throw caml_maybe_attach_backtrace(exn$0, 0); var msg$0 = exn$0[2], - _J_ = bad_input(msg$0), - fmt$5 = _J_[2], - fmt$4 = _J_[1]; + _K_ = bad_input(msg$0), + fmt$5 = _K_[2], + fmt$4 = _K_[1]; } /*<>*/ return [0, [0, fmt$4, s$0], @@ -29541,19 +29625,19 @@ /*<>*/ var rest$19 = fmt$0[2], formatting_lit = fmt$0[1], - /*<>*/ _O_ = + /*<>*/ _P_ = /*<>*/ caml_call1 (CamlinternalFormat[17], formatting_lit), - /*<>*/ _P_ = - function(_R_){ /*<>*/ return check_char(ib, _R_);}; + /*<>*/ _Q_ = + function(_S_){ /*<>*/ return check_char(ib, _S_);}; /*<>*/ /*<>*/ caml_call2 - (Stdlib_String[30], _P_, _O_); + (Stdlib_String[30], _Q_, _P_); var fmt$0 = rest$19; break; case 18: - var _Q_ = fmt$0[1]; - if(0 === _Q_[0]){ - var rest$20 = fmt$0[2], fmt$9 = _Q_[1][1]; + var _R_ = fmt$0[1]; + if(0 === _R_[0]){ + var rest$20 = fmt$0[2], fmt$9 = _R_[1][1]; /*<>*/ check_char(ib, 64); /*<>*/ check_char(ib, 123); /*<>*/ var @@ -29563,7 +29647,7 @@ fmt$0 = fmt$10; } else{ - var rest$21 = fmt$0[2], fmt$11 = _Q_[1][1]; + var rest$21 = fmt$0[2], fmt$11 = _R_[1][1]; /*<>*/ check_char(ib, 64); /*<>*/ check_char(ib, 91); /*<>*/ var @@ -29672,16 +29756,16 @@ if(exc[1] !== Stdlib[6]) throw caml_maybe_attach_backtrace(exc, 0); /*<>*/ var msg = exc[2], - /*<>*/ _C_ = - /*<>*/ caml_call1(Stdlib_String[25], str), /*<>*/ _D_ = - /*<>*/ caml_call2(Stdlib[28], _C_, cst$0), - /*<>*/ _E_ = - /*<>*/ caml_call2(Stdlib[28], cst_in_format, _D_), - /*<>*/ _F_ = - /*<>*/ caml_call2(Stdlib[28], msg, _E_); + /*<>*/ caml_call1(Stdlib_String[25], str), + /*<>*/ _E_ = + /*<>*/ caml_call2(Stdlib[28], _D_, cst$0), + /*<>*/ _F_ = + /*<>*/ caml_call2(Stdlib[28], cst_in_format, _E_), + /*<>*/ _G_ = + /*<>*/ caml_call2(Stdlib[28], msg, _F_); /*<>*/ return /*<>*/ caml_call1 - (Stdlib[1], _F_); + (Stdlib[1], _G_); } /*<>*/ return /*<>*/ caml_call2 (ef, ib, exc); @@ -29712,15 +29796,15 @@ fmt); /*<>*/ } function kscanf_opt(ib, fmt){ - function _A_(x){ + function _B_(x){ /*<>*/ return [0, x]; /*<>*/ } /*<>*/ return kscanf_gen (ib, - function(param, _B_){ + function(param, _C_){ /*<>*/ return 0; /*<>*/ }, - _A_, + _B_, fmt); /*<>*/ } function bscanf(ib, fmt){ @@ -29751,10 +29835,10 @@ str = token_string(ib); /*<>*/ try{ /*<>*/ var - /*<>*/ _z_ = + /*<>*/ _A_ = /*<>*/ caml_call2 (CamlinternalFormat[15], str, format), - fmt = _z_; + fmt = _A_; } catch(exn$0){ var exn = caml_wrap_exception(exn$0); @@ -29768,30 +29852,30 @@ /*<>*/ return bscanf_format(from_string(s), format, f); /*<>*/ } function format_from_string(s, fmt){ - /*<>*/ function _w_(x){ + /*<>*/ function _x_(x){ /*<>*/ return x; /*<>*/ } /*<>*/ var - /*<>*/ _x_ = - /*<>*/ caml_call1(Stdlib_String[25], s), /*<>*/ _y_ = - /*<>*/ caml_call2(Stdlib[28], _x_, cst$1); + /*<>*/ caml_call1(Stdlib_String[25], s), + /*<>*/ _z_ = + /*<>*/ caml_call2(Stdlib[28], _y_, cst$1); /*<>*/ return sscanf_format - ( /*<>*/ caml_call2(Stdlib[28], cst$2, _y_), + ( /*<>*/ caml_call2(Stdlib[28], cst$2, _z_), fmt, - _w_); + _x_); /*<>*/ } function unescaped(s){ - /*<>*/ function _u_(x){ + /*<>*/ function _v_(x){ /*<>*/ return x; /*<>*/ } /*<>*/ /*<>*/ var - _v_ = /*<>*/ caml_call2(Stdlib[28], s, cst$3); + _w_ = /*<>*/ caml_call2(Stdlib[28], s, cst$3); /*<>*/ return /*<>*/ caml_call1 (sscanf - ( /*<>*/ caml_call2(Stdlib[28], cst$4, _v_), + ( /*<>*/ caml_call2(Stdlib[28], cst$4, _w_), _t_), - _u_); + _v_); /*<>*/ } var Stdlib_Scanf = @@ -31156,6 +31240,7 @@ : runtime.caml_call_gen(f, [a0, a1, a2]); } var + _d_ = undefined, global_data = runtime.caml_get_global_data(), Stdlib_List = global_data.Stdlib__List, Stdlib = global_data.Stdlib, @@ -31174,7 +31259,7 @@ /*<>*/ /*<>*/ var prng = [246, - function(_aM_){ /*<>*/ return caml_call1(Stdlib_Random[15][2], 0);}]; + function(_aN_){ /*<>*/ return caml_call1(Stdlib_Random[15][2], 0);}]; function create(opt, initial_size){ /*<>*/ if(opt) var sth = opt[1], random = sth; @@ -31185,17 +31270,17 @@ /*<>*/ for(;;){ if(initial_size > x && Stdlib_Sys[13] >= (x * 2 | 0)){var x$0 = x * 2 | 0, x = x$0; continue;} /*<>*/ if(random){ - var _aK_ = runtime.caml_obj_tag(prng); + var _aL_ = runtime.caml_obj_tag(prng); a: - if(250 === _aK_) - var _aL_ = prng[1]; + if(250 === _aL_) + var _aM_ = prng[1]; else{ - if(246 !== _aK_ && 244 !== _aK_){var _aL_ = prng; break a;} - var _aL_ = caml_call1(CamlinternalLazy[2], prng); + if(246 !== _aL_ && 244 !== _aL_){var _aM_ = prng; break a;} + var _aM_ = caml_call1(CamlinternalLazy[2], prng); } var seed = - /*<>*/ caml_call1(Stdlib_Random[15][4], _aL_); + /*<>*/ caml_call1(Stdlib_Random[15][4], _aM_); } else var seed = 0; @@ -31210,16 +31295,16 @@ /*<>*/ h[1] = 0; /*<>*/ var len = h[2].length - 1, - /*<>*/ _aI_ = len - 1 | 0, - _aH_ = 0; - if(_aI_ >= 0){ - var i = _aH_; + /*<>*/ _aJ_ = len - 1 | 0, + _aI_ = 0; + if(_aJ_ >= 0){ + var i = _aI_; for(;;){ /*<>*/ caml_check_bound(h[2], i)[1 + i] = 0; /*<>*/ /*<>*/ var - _aJ_ = i + 1 | 0; - if(_aI_ === i) break; - var i = _aJ_; + _aK_ = i + 1 | 0; + if(_aJ_ === i) break; + var i = _aK_; } } return 0; @@ -31236,11 +31321,11 @@ /*<>*/ } function copy(h){ /*<>*/ var - _aE_ = h[4], - _aF_ = h[3], - /*<>*/ _aG_ = + _aF_ = h[4], + _aG_ = h[3], + /*<>*/ _aH_ = /*<>*/ caml_call1(Stdlib_Array[6], h[2]); - /*<>*/ return [0, h[1], _aG_, _aF_, _aE_]; + /*<>*/ return [0, h[1], _aH_, _aG_, _aF_]; /*<>*/ } function key_index(h, hkey){ /*<>*/ return hkey & (h[2].length - 1 - 1 | 0); @@ -31260,16 +31345,16 @@ var param$0 = rest; } /*<>*/ } - var d = h[2], _aC_ = d.length - 1 - 1 | 0, _aB_ = 0; - if(_aC_ >= 0){ - var i = _aB_; + var d = h[2], _aD_ = d.length - 1 - 1 | 0, _aC_ = 0; + if(_aD_ >= 0){ + var i = _aC_; for(;;){ /*<>*/ d[1 + i] = do_bucket(caml_check_bound(d, i)[1 + i]); /*<>*/ /*<>*/ var - _aD_ = i + 1 | 0; - if(_aC_ === i) break; - var i = _aD_; + _aE_ = i + 1 | 0; + if(_aD_ === i) break; + var i = _aE_; } } return 0; @@ -31281,9 +31366,9 @@ nsize = osize * 2 | 0; /*<>*/ clean(h); var - _av_ = nsize < Stdlib_Sys[13] ? 1 : 0, - _aw_ = _av_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _av_; - if(_aw_){ + _aw_ = nsize < Stdlib_Sys[13] ? 1 : 0, + _ax_ = _aw_ ? (osize >>> 1 | 0) <= h[1] ? 1 : 0 : _aw_; + if(_ax_){ /*<>*/ /*<>*/ var ndata = /*<>*/ caml_make_vect(nsize, 0); h[2] = ndata; @@ -31291,33 +31376,33 @@ insert_bucket = function(param){ /*<>*/ if(! param) - /*<>*/ return 0; + /*<>*/ return; var rest = param[3], data = param[2], hkey = param[1]; /*<>*/ insert_bucket(rest); /*<>*/ /*<>*/ var nidx = key_index(h, hkey); /*<>*/ ndata[1 + nidx] = [0, hkey, data, caml_check_bound(ndata, nidx)[1 + nidx]]; - /*<>*/ return 0; + /*<>*/ return; /*<>*/ }, - /*<>*/ _ay_ = osize - 1 | 0, - /*<>*/ _ax_ = 0; - if(_ay_ >= 0){ - var i = _ax_; + /*<>*/ _az_ = osize - 1 | 0, + /*<>*/ _ay_ = 0; + if(_az_ >= 0){ + var i = _ay_; for(;;){ /*<>*/ insert_bucket (caml_check_bound(odata, i)[1 + i]); /*<>*/ /*<>*/ var - _aA_ = i + 1 | 0; - if(_ay_ === i) break; - var i = _aA_; + _aB_ = i + 1 | 0; + if(_az_ === i) break; + var i = _aB_; } } - var _az_ = 0; + var _aA_ = 0; } else - var _az_ = _aw_; - return _az_; + var _aA_ = _ax_; + return _aA_; /*<>*/ } function add(h, key, info){ /*<>*/ var @@ -31330,8 +31415,8 @@ [0, hkey, container, caml_check_bound(h[2], i)[1 + i]]; /*<>*/ caml_check_bound(h[2], i)[1 + i] = bucket; h[1] = h[1] + 1 | 0; - var _au_ = h[2].length - 1 << 1 < h[1] ? 1 : 0; - return _au_ ? resize(h) : _au_; + var _av_ = h[2].length - 1 << 1 < h[1] ? 1 : 0; + return _av_ ? resize(h) : _av_; /*<>*/ } function remove(h, key){ /*<>*/ /*<>*/ var @@ -31359,17 +31444,17 @@ /*<>*/ } /*<>*/ var /*<>*/ i = key_index(h, hkey), - /*<>*/ _at_ = + /*<>*/ _au_ = remove_bucket(caml_check_bound(h[2], i)[1 + i]); - /*<>*/ caml_check_bound(h[2], i)[1 + i] = _at_; + /*<>*/ caml_check_bound(h[2], i)[1 + i] = _au_; /*<>*/ return 0; /*<>*/ } function find(h, key){ /*<>*/ var /*<>*/ hkey = /*<>*/ caml_call2(H[2], h[3], key), - /*<>*/ _as_ = key_index(h, hkey), - param = caml_check_bound(h[2], _as_)[1 + _as_]; + /*<>*/ _at_ = key_index(h, hkey), + param = caml_check_bound(h[2], _at_)[1 + _at_]; for(;;){ if(! param) /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace @@ -31395,8 +31480,8 @@ /*<>*/ var /*<>*/ hkey = /*<>*/ caml_call2(H[2], h[3], key), - /*<>*/ _ar_ = key_index(h, hkey), - param = caml_check_bound(h[2], _ar_)[1 + _ar_]; + /*<>*/ _as_ = key_index(h, hkey), + param = caml_check_bound(h[2], _as_)[1 + _as_]; for(;;){ if(! param) /*<>*/ return 0; var hk = param[1], rest = param[3], c = param[2]; @@ -31444,9 +31529,9 @@ } /*<>*/ } /*<>*/ /*<>*/ var - _aq_ = key_index(h, hkey); + _ar_ = key_index(h, hkey); /*<>*/ return find_in_bucket - (caml_check_bound(h[2], _aq_)[1 + _aq_]); + (caml_check_bound(h[2], _ar_)[1 + _ar_]); /*<>*/ } function replace(h, key, info){ /*<>*/ var @@ -31464,8 +31549,8 @@ if(hkey === hk){ if(! /*<>*/ caml_call2(H[3], c, key)){ /*<>*/ /*<>*/ var - _am_ = /*<>*/ caml_call3(H[5], c, key, info); - /*<>*/ return _am_; + _an_ = /*<>*/ caml_call3(H[5], c, key, info); + /*<>*/ return _an_; } var param = next; } @@ -31473,23 +31558,23 @@ var next$0 = param[3], param = next$0; } } - catch(_ap_){ - var _an_ = caml_wrap_exception(_ap_); - if(_an_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_an_, 0); + catch(_aq_){ + var _ao_ = caml_wrap_exception(_aq_); + if(_ao_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_ao_, 0); /*<>*/ /*<>*/ var container = /*<>*/ caml_call2(H[1], key, info); /*<>*/ caml_check_bound(h[2], i)[1 + i] = [0, hkey, container, l]; h[1] = h[1] + 1 | 0; - var _ao_ = h[2].length - 1 << 1 < h[1] ? 1 : 0; - return _ao_ ? resize(h) : _ao_; + var _ap_ = h[2].length - 1 << 1 < h[1] ? 1 : 0; + return _ap_ ? resize(h) : _ap_; } /*<>*/ } function mem(h, key){ /*<>*/ var /*<>*/ hkey = /*<>*/ caml_call2(H[2], h[3], key), - /*<>*/ _al_ = key_index(h, hkey), - param = caml_check_bound(h[2], _al_)[1 + _al_]; + /*<>*/ _am_ = key_index(h, hkey), + param = caml_check_bound(h[2], _am_)[1 + _am_]; /*<>*/ for(;;){ if(! param) /*<>*/ return 0; var hk = param[1], rest = param[3], c = param[2]; @@ -31517,21 +31602,21 @@ } } function stats(h){ - /*<>*/ var _af_ = h[2], _ag_ = 0; - function _ah_(m, b){ + /*<>*/ var _ag_ = h[2], _ah_ = 0; + function _ai_(m, b){ /*<>*/ /*<>*/ var - _ak_ = bucket_length(0, b); + _al_ = bucket_length(0, b); /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Int[11], m, _ak_); + (Stdlib_Int[11], m, _al_); /*<>*/ } /*<>*/ var /*<>*/ mbl = /*<>*/ caml_call3 - (Stdlib_Array[17], _ah_, _ag_, _af_), + (Stdlib_Array[17], _ai_, _ah_, _ag_), /*<>*/ histo = /*<>*/ caml_make_vect(mbl + 1 | 0, 0), - /*<>*/ _ai_ = h[2]; - function _aj_(b){ + /*<>*/ _aj_ = h[2]; + function _ak_(b){ /*<>*/ /*<>*/ var l = bucket_length(0, b); /*<>*/ histo[1 + l] = @@ -31539,7 +31624,7 @@ /*<>*/ return 0; /*<>*/ } /*<>*/ /*<>*/ caml_call2 - (Stdlib_Array[11], _aj_, _ai_); + (Stdlib_Array[11], _ak_, _aj_); /*<>*/ return [0, h[1], h[2].length - 1, mbl, histo]; /*<>*/ } function bucket_length_alive(accu, param){ @@ -31557,22 +31642,22 @@ function stats_alive(h){ /*<>*/ var /*<>*/ size = [0, 0], - /*<>*/ _$_ = h[2], - _aa_ = 0; - function _ab_(m, b){ + /*<>*/ _aa_ = h[2], + _ab_ = 0; + function _ac_(m, b){ /*<>*/ /*<>*/ var - _ae_ = bucket_length_alive(0, b); + _af_ = bucket_length_alive(0, b); /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Int[11], m, _ae_); + (Stdlib_Int[11], m, _af_); /*<>*/ } /*<>*/ var /*<>*/ mbl = /*<>*/ caml_call3 - (Stdlib_Array[17], _ab_, _aa_, _$_), + (Stdlib_Array[17], _ac_, _ab_, _aa_), /*<>*/ histo = /*<>*/ caml_make_vect(mbl + 1 | 0, 0), - /*<>*/ _ac_ = h[2]; - function _ad_(b){ + /*<>*/ _ad_ = h[2]; + function _ae_(b){ /*<>*/ /*<>*/ var l = bucket_length_alive(0, b); size[1] = size[1] + l | 0; @@ -31581,7 +31666,7 @@ /*<>*/ return 0; /*<>*/ } /*<>*/ /*<>*/ caml_call2 - (Stdlib_Array[11], _ad_, _ac_); + (Stdlib_Array[11], _ae_, _ad_); /*<>*/ return [0, size[1], h[2].length - 1, @@ -31589,20 +31674,20 @@ histo]; /*<>*/ } function add_seq(tbl, i){ - function ___(param){ + function _$_(param){ /*<>*/ var v = param[2], k = param[1]; /*<>*/ return add(tbl, k, v); /*<>*/ } /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Seq[4], ___, i); + (Stdlib_Seq[4], _$_, i); /*<>*/ } function replace_seq(tbl, i){ - function _Z_(param){ + function ___(param){ /*<>*/ var v = param[2], k = param[1]; /*<>*/ return replace(tbl, k, v); /*<>*/ } /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Seq[4], _Z_, i); + (Stdlib_Seq[4], ___, i); /*<>*/ } function of_seq(i){ /*<>*/ /*<>*/ var @@ -31639,8 +31724,9 @@ (Stdlib_Obj[24][3], t, 0); /*<>*/ } function set_key(t, k){ - /*<>*/ return /*<>*/ caml_call3 - (Stdlib_Obj[24][5], t, 0, k); + /*<>*/ /*<>*/ caml_call3 + (Stdlib_Obj[24][5], t, 0, k); + /*<>*/ return; /*<>*/ } function check_key(t){ /*<>*/ return /*<>*/ caml_call2 @@ -31726,10 +31812,10 @@ replace_seq = include[15], clean = include[17], stats_alive = include[18], - _Y_ = include[1]; + _Z_ = include[1]; function create(sz){ /*<>*/ return /*<>*/ caml_call2 - (_Y_, _a_, sz); + (_Z_, _a_, sz); /*<>*/ } function of_seq(i){ /*<>*/ /*<>*/ var @@ -31762,8 +31848,8 @@ /*<>*/ return [0, 0]; /*<>*/ } function add(b, k, d){ - /*<>*/ var _X_ = b[1]; - b[1] = [0, make(k, d), _X_]; + /*<>*/ var _Y_ = b[1]; + b[1] = [0, make(k, d), _Y_]; return 0; /*<>*/ } function test_key(k, e){ @@ -31792,13 +31878,13 @@ } /*<>*/ } function find(b, k){ - /*<>*/ var _U_ = b[1]; - /*<>*/ function _V_(_W_){ - /*<>*/ return test_key(k, _W_); + /*<>*/ var _V_ = b[1]; + /*<>*/ function _W_(_X_){ + /*<>*/ return test_key(k, _X_); } /*<>*/ /*<>*/ var match = - /*<>*/ caml_call2(Stdlib_List[40], _V_, _U_); + /*<>*/ caml_call2(Stdlib_List[40], _W_, _V_); if(! match) /*<>*/ return 0; var e = match[1]; /*<>*/ return get_data(e); @@ -31819,16 +31905,18 @@ (Stdlib_Obj[24][3], t, 0); /*<>*/ } function set_key1(t, k){ - /*<>*/ return /*<>*/ caml_call3 - (Stdlib_Obj[24][5], t, 0, k); + /*<>*/ /*<>*/ caml_call3 + (Stdlib_Obj[24][5], t, 0, k); + /*<>*/ return; /*<>*/ } function get_key2(t){ /*<>*/ return /*<>*/ caml_call2 (Stdlib_Obj[24][3], t, 1); /*<>*/ } function set_key2(t, k){ - /*<>*/ return /*<>*/ caml_call3 - (Stdlib_Obj[24][5], t, 1, k); + /*<>*/ /*<>*/ caml_call3 + (Stdlib_Obj[24][5], t, 1, k); + /*<>*/ return; /*<>*/ } function get_data$0(t){ /*<>*/ return /*<>*/ caml_call1 @@ -31873,11 +31961,11 @@ /*<>*/ var k2 = param[2], k1 = param[1], - /*<>*/ _T_ = + /*<>*/ _U_ = /*<>*/ caml_call2(H2[2], seed, k2) * 65599 | 0; /*<>*/ return /*<>*/ caml_call2 (H1[2], seed, k1) - + _T_ + + _U_ | 0; } function equal(c, param){ @@ -31906,11 +31994,11 @@ } function check_key(c){ /*<>*/ /*<>*/ var - _S_ = /*<>*/ caml_call2(Stdlib_Obj[24][7], c, 0); - /*<>*/ return _S_ + _T_ = /*<>*/ caml_call2(Stdlib_Obj[24][7], c, 0); + /*<>*/ return _T_ ? /*<>*/ caml_call2 (Stdlib_Obj[24][7], c, 1) - : _S_; + : _T_; /*<>*/ } /*<>*/ return MakeSeeded ([0, @@ -31929,13 +32017,13 @@ /*<>*/ } /*<>*/ var equal$0 = H1[1], - /*<>*/ _Q_ = [0, equal, seeded_hash]; + /*<>*/ _R_ = [0, equal, seeded_hash]; function seeded_hash$0(seed, x){ /*<>*/ return /*<>*/ caml_call1 (H1[2], x); /*<>*/ } var - include = MakeSeeded$1([0, equal$0, seeded_hash$0], _Q_), + include = MakeSeeded$1([0, equal$0, seeded_hash$0], _R_), clear = include[2], reset = include[3], copy = include[4], @@ -31952,10 +32040,10 @@ replace_seq = include[15], clean = include[17], stats_alive = include[18], - _R_ = include[1]; + _S_ = include[1]; function create(sz){ /*<>*/ return /*<>*/ caml_call2 - (_R_, _b_, sz); + (_S_, _b_, sz); /*<>*/ } function of_seq(i){ /*<>*/ /*<>*/ var @@ -31988,8 +32076,8 @@ /*<>*/ return [0, 0]; /*<>*/ } function add$0(b, k1, k2, d){ - /*<>*/ var _P_ = b[1]; - b[1] = [0, make$1(k1, k2, d), _P_]; + /*<>*/ var _Q_ = b[1]; + b[1] = [0, make$1(k1, k2, d), _Q_]; return 0; /*<>*/ } function test_keys(k1, k2, e){ @@ -32019,13 +32107,13 @@ } /*<>*/ } function find$0(b, k1, k2){ - /*<>*/ var _M_ = b[1]; - /*<>*/ function _N_(_O_){ - /*<>*/ return test_keys(k1, k2, _O_); + /*<>*/ var _N_ = b[1]; + /*<>*/ function _O_(_P_){ + /*<>*/ return test_keys(k1, k2, _P_); } /*<>*/ /*<>*/ var match = - /*<>*/ caml_call2(Stdlib_List[40], _N_, _M_); + /*<>*/ caml_call2(Stdlib_List[40], _O_, _N_); if(! match) /*<>*/ return 0; var e = match[1]; /*<>*/ return get_data$0(e); @@ -32050,8 +32138,9 @@ (Stdlib_Obj[24][3], t, n); /*<>*/ } function set_key$0(t, n, k){ - /*<>*/ return /*<>*/ caml_call3 - (Stdlib_Obj[24][5], t, n, k); + /*<>*/ /*<>*/ caml_call3 + (Stdlib_Obj[24][5], t, n, k); + /*<>*/ return; /*<>*/ } function get_data$1(t){ /*<>*/ return /*<>*/ caml_call1 @@ -32067,17 +32156,17 @@ /*<>*/ eph = create$1(l); /*<>*/ set_data$1(eph, data); /*<>*/ var - _K_ = l - 1 | 0, - /*<>*/ _J_ = 0; - if(_K_ >= 0){ - var i = _J_; + _L_ = l - 1 | 0, + /*<>*/ _K_ = 0; + if(_L_ >= 0){ + var i = _K_; for(;;){ /*<>*/ set_key$0 (eph, i, caml_check_bound(keys, i)[1 + i]); /*<>*/ /*<>*/ var - _L_ = i + 1 | 0; - if(_K_ === i) break; - var i = _L_; + _M_ = i + 1 | 0; + if(_L_ === i) break; + var i = _M_; } } /*<>*/ return eph; @@ -32090,10 +32179,10 @@ /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace (Stdlib[3], 1); /*<>*/ var - /*<>*/ _F_ = l - 1 | 0, - /*<>*/ _E_ = 0; - if(_F_ >= 0){ - var i = _E_; + /*<>*/ _G_ = l - 1 | 0, + /*<>*/ _F_ = 0; + if(_G_ >= 0){ + var i = _F_; for(;;){ /*<>*/ /*<>*/ var match = get_key$0(eph, i); @@ -32105,19 +32194,19 @@ /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace (Stdlib[3], 1); /*<>*/ /*<>*/ var - _H_ = i + 1 | 0; - if(_F_ === i) break; - var i = _H_; + _I_ = i + 1 | 0; + if(_G_ === i) break; + var i = _I_; } } /*<>*/ /*<>*/ var - _G_ = get_data$1(eph); - /*<>*/ return _G_; + _H_ = get_data$1(eph); + /*<>*/ return _H_; } - catch(_I_){ - var _D_ = caml_wrap_exception(_I_); - if(_D_ === Stdlib[3]) /*<>*/ return 0; - throw caml_maybe_attach_backtrace(_D_, 0); + catch(_J_){ + var _E_ = caml_wrap_exception(_J_); + if(_E_ === Stdlib[3]) /*<>*/ return 0; + throw caml_maybe_attach_backtrace(_E_, 0); } /*<>*/ } function MakeSeeded$2(H){ @@ -32126,17 +32215,17 @@ c = create$1(k.length - 1); /*<>*/ set_data$1(c, d); /*<>*/ var - _B_ = k.length - 1 - 1 | 0, - /*<>*/ _A_ = 0; - if(_B_ >= 0){ - var i = _A_; + _C_ = k.length - 1 - 1 | 0, + /*<>*/ _B_ = 0; + if(_C_ >= 0){ + var i = _B_; for(;;){ /*<>*/ set_key$0 (c, i, caml_check_bound(k, i)[1 + i]); /*<>*/ /*<>*/ var - _C_ = i + 1 | 0; - if(_B_ === i) break; - var i = _C_; + _D_ = i + 1 | 0; + if(_C_ === i) break; + var i = _D_; } } /*<>*/ return c; @@ -32144,22 +32233,22 @@ function seeded_hash(seed, k){ /*<>*/ var /*<>*/ h = [0, 0], - _w_ = k.length - 1 - 1 | 0, - /*<>*/ _v_ = 0; - if(_w_ >= 0){ - var i = _v_; + _x_ = k.length - 1 - 1 | 0, + /*<>*/ _w_ = 0; + if(_x_ >= 0){ + var i = _w_; for(;;){ /*<>*/ var - _x_ = h[1], - /*<>*/ _y_ = caml_check_bound(k, i)[1 + i]; + _y_ = h[1], + /*<>*/ _z_ = caml_check_bound(k, i)[1 + i]; h[1] = - ( /*<>*/ caml_call2(H[2], seed, _y_) * 65599 | 0) - + _x_ + ( /*<>*/ caml_call2(H[2], seed, _z_) * 65599 | 0) + + _y_ | 0; /*<>*/ /*<>*/ var - _z_ = i + 1 | 0; - if(_w_ === i) break; - var i = _z_; + _A_ = i + 1 | 0; + if(_x_ === i) break; + var i = _A_; } } return h[1]; @@ -32179,9 +32268,9 @@ if(! match) /*<>*/ return 2; /*<>*/ var ki = match[1], - /*<>*/ _u_ = caml_check_bound(k, i)[1 + i]; + /*<>*/ _v_ = caml_check_bound(k, i)[1 + i]; /*<>*/ if - (! /*<>*/ caml_call2(H[1], _u_, ki)) + (! /*<>*/ caml_call2(H[1], _v_, ki)) /*<>*/ return 1; /*<>*/ var /*<>*/ i$0 = i - 1 | 0, @@ -32192,17 +32281,17 @@ /*<>*/ /*<>*/ caml_call1 (Stdlib_Obj[24][12], c); /*<>*/ var - _s_ = k.length - 1 - 1 | 0, - /*<>*/ _r_ = 0; - if(_s_ >= 0){ - var i = _r_; + _t_ = k.length - 1 - 1 | 0, + /*<>*/ _s_ = 0; + if(_t_ >= 0){ + var i = _s_; for(;;){ /*<>*/ set_key$0 (c, i, caml_check_bound(k, i)[1 + i]); /*<>*/ /*<>*/ var - _t_ = i + 1 | 0; - if(_s_ === i) break; - var i = _t_; + _u_ = i + 1 | 0; + if(_t_ === i) break; + var i = _u_; } } /*<>*/ return set_data$1(c, d); @@ -32212,19 +32301,19 @@ /*<>*/ i$1 = length$1(c) - 1 | 0, i = i$1; /*<>*/ for(;;){ - var _p_ = i < 0 ? 1 : 0; - if(_p_) - var _q_ = _p_; + var _q_ = i < 0 ? 1 : 0; + if(_q_) + var _r_ = _q_; else{ /*<>*/ /*<>*/ var - _o_ = /*<>*/ caml_call2(Stdlib_Obj[24][7], c, i); - /*<>*/ if(_o_){ + _p_ = /*<>*/ caml_call2(Stdlib_Obj[24][7], c, i); + /*<>*/ if(_p_){ var i$0 = i - 1 | 0, i = i$0; continue; } - var _q_ = _o_; + var _r_ = _p_; } - return _q_; + return _r_; } /*<>*/ } /*<>*/ return MakeSeeded @@ -32260,10 +32349,10 @@ replace_seq = include[15], clean = include[17], stats_alive = include[18], - _n_ = include[1]; + _o_ = include[1]; function create(sz){ /*<>*/ return /*<>*/ caml_call2 - (_n_, _c_, sz); + (_o_, _c_, sz); /*<>*/ } function of_seq(i){ /*<>*/ /*<>*/ var @@ -32296,8 +32385,8 @@ /*<>*/ return [0, 0]; /*<>*/ } function add$1(b, k, d){ - /*<>*/ var _m_ = b[1]; - b[1] = [0, make$3(k, d), _m_]; + /*<>*/ var _n_ = b[1]; + b[1] = [0, make$3(k, d), _n_]; return 0; /*<>*/ } function test_keys$0(k, e){ @@ -32306,10 +32395,10 @@ /*<>*/ throw /*<>*/ caml_maybe_attach_backtrace (Stdlib[3], 1); /*<>*/ var - _i_ = k.length - 1 - 1 | 0, - /*<>*/ _h_ = 0; - if(_i_ >= 0){ - var i = _h_; + _j_ = k.length - 1 - 1 | 0, + /*<>*/ _i_ = 0; + if(_j_ >= 0){ + var i = _i_; for(;;){ /*<>*/ /*<>*/ var match = get_key$0(e, i); @@ -32317,9 +32406,9 @@ var x = match[1]; if(x === caml_check_bound(k, i)[1 + i]){ /*<>*/ /*<>*/ var - _k_ = i + 1 | 0; - if(_i_ === i) break; - var i = _k_; + _l_ = i + 1 | 0; + if(_j_ === i) break; + var i = _l_; continue; } } @@ -32327,13 +32416,13 @@ (Stdlib[3], 1); } } - /*<>*/ /*<>*/ var _j_ = 1; - /*<>*/ return _j_; + /*<>*/ /*<>*/ var _k_ = 1; + /*<>*/ return _k_; } - catch(_l_){ - var _g_ = caml_wrap_exception(_l_); - if(_g_ === Stdlib[3]) /*<>*/ return 0; - throw caml_maybe_attach_backtrace(_g_, 0); + catch(_m_){ + var _h_ = caml_wrap_exception(_m_); + if(_h_ === Stdlib[3]) /*<>*/ return 0; + throw caml_maybe_attach_backtrace(_h_, 0); } /*<>*/ } function remove$1(b, k){ @@ -32353,13 +32442,13 @@ } /*<>*/ } function find$1(b, k){ - /*<>*/ var _d_ = b[1]; - /*<>*/ function _e_(_f_){ - /*<>*/ return test_keys$0(k, _f_); + /*<>*/ var _e_ = b[1]; + /*<>*/ function _f_(_g_){ + /*<>*/ return test_keys$0(k, _g_); } /*<>*/ /*<>*/ var match = - /*<>*/ caml_call2(Stdlib_List[40], _e_, _d_); + /*<>*/ caml_call2(Stdlib_List[40], _f_, _e_); if(! match) /*<>*/ return 0; var e = match[1]; /*<>*/ return get_data$1(e); @@ -32424,8 +32513,6 @@ caml_string_get = runtime.caml_string_get, caml_string_notequal = runtime.caml_string_notequal, caml_sys_getenv = runtime.caml_sys_getenv, - caml_trampoline = runtime.caml_trampoline, - caml_trampoline_return = runtime.caml_trampoline_return, caml_wrap_exception = runtime.caml_wrap_exception; /*<>*/ function caml_call1(f, a0){ return (f.l >= 0 ? f.l : f.l = f.length) == 1 @@ -32448,6 +32535,7 @@ : runtime.caml_call_gen(f, [a0, a1, a2, a3]); } var + _m_ = undefined, global_data = runtime.caml_get_global_data(), cst$18 = cst$19, cst$17 = cst$19, @@ -32584,39 +32672,39 @@ /*<>*/ } function is_relative(n){ /*<>*/ var - _aM_ = caml_ml_string_length(n) < 1 ? 1 : 0, - _aN_ = - _aM_ + _aK_ = caml_ml_string_length(n) < 1 ? 1 : 0, + _aL_ = + _aK_ || (47 !== /*<>*/ caml_string_get(n, 0) ? 1 : 0); - return _aN_; + return _aL_; /*<>*/ } function is_implicit(n){ /*<>*/ /*<>*/ var - _aH_ = is_relative(n); - /*<>*/ if(_aH_){ + _aF_ = is_relative(n); + /*<>*/ if(_aF_){ var - _aI_ = caml_ml_string_length(n) < 2 ? 1 : 0, - _aJ_ = - _aI_ + _aG_ = caml_ml_string_length(n) < 2 ? 1 : 0, + _aH_ = + _aG_ || /*<>*/ caml_string_notequal ( /*<>*/ caml_call3(Stdlib_String[16], n, 0, 2), cst$27); - /*<>*/ if(_aJ_) + /*<>*/ if(_aH_) var - _aK_ = caml_ml_string_length(n) < 3 ? 1 : 0, - _aL_ = - _aK_ + _aI_ = caml_ml_string_length(n) < 3 ? 1 : 0, + _aJ_ = + _aI_ || /*<>*/ caml_string_notequal ( /*<>*/ caml_call3(Stdlib_String[16], n, 0, 3), cst$28); else - var _aL_ = _aJ_; + var _aJ_ = _aH_; } else - var _aL_ = _aH_; - /*<>*/ return _aL_; + var _aJ_ = _aF_; + /*<>*/ return _aJ_; /*<>*/ } function check_suffix(name, suff){ /*<>*/ return /*<>*/ caml_call2 @@ -32644,8 +32732,8 @@ /*<>*/ caml_sys_getenv("TMPDIR"), temp_dir_name = _l_; } - catch(_aG_){ - var _a_ = caml_wrap_exception(_aG_); + catch(_aE_){ + var _a_ = caml_wrap_exception(_aE_); if(_a_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_a_, 0); var temp_dir_name = cst_tmp; } @@ -32657,10 +32745,10 @@ /*<>*/ /*<>*/ caml_call2 (Stdlib_Buffer[12], b, 39); /*<>*/ var - _aD_ = l - 1 | 0, - /*<>*/ _aC_ = 0; - if(_aD_ >= 0){ - var i = _aC_; + _aB_ = l - 1 | 0, + /*<>*/ _aA_ = 0; + if(_aB_ >= 0){ + var i = _aA_; for(;;){ /*<>*/ if (39 === /*<>*/ caml_string_get(s, i)) @@ -32668,14 +32756,14 @@ (Stdlib_Buffer[16], b, quotequote); else{ /*<>*/ /*<>*/ var - _aF_ = /*<>*/ caml_string_get(s, i); + _aD_ = /*<>*/ caml_string_get(s, i); /*<>*/ /*<>*/ caml_call2 - (Stdlib_Buffer[12], b, _aF_); + (Stdlib_Buffer[12], b, _aD_); } /*<>*/ /*<>*/ var - _aE_ = i + 1 | 0; - if(_aD_ === i) break; - var i = _aE_; + _aC_ = i + 1 | 0; + if(_aB_ === i) break; + var i = _aC_; } } /*<>*/ /*<>*/ caml_call2 @@ -32688,47 +32776,47 @@ var f = stderr[1]; /*<>*/ if ( /*<>*/ caml_equal(stderr, stdout)) - var _ar_ = cst_2_1; + var _ap_ = cst_2_1; else /*<>*/ var - /*<>*/ _aB_ = quote(f), - _ar_ = /*<>*/ caml_call2(Stdlib[28], cst_2, _aB_); - var _as_ = _ar_; + /*<>*/ _az_ = quote(f), + _ap_ = /*<>*/ caml_call2(Stdlib[28], cst_2, _az_); + var _aq_ = _ap_; } else - var _as_ = cst$4; + var _aq_ = cst$4; if(stdout) /*<>*/ var f$0 = stdout[1], - /*<>*/ _at_ = quote(f$0), - _au_ = /*<>*/ caml_call2(Stdlib[28], cst, _at_); + /*<>*/ _ar_ = quote(f$0), + _as_ = /*<>*/ caml_call2(Stdlib[28], cst, _ar_); else - var _au_ = cst$3; + var _as_ = cst$3; /*<>*/ /*<>*/ var - _av_ = /*<>*/ caml_call2(Stdlib[28], _au_, _as_); + _at_ = /*<>*/ caml_call2(Stdlib[28], _as_, _aq_); if(stdin) /*<>*/ var f$1 = stdin[1], - /*<>*/ _aw_ = quote(f$1), - _ax_ = /*<>*/ caml_call2(Stdlib[28], cst$0, _aw_); + /*<>*/ _au_ = quote(f$1), + _av_ = /*<>*/ caml_call2(Stdlib[28], cst$0, _au_); else - var _ax_ = cst$2; + var _av_ = cst$2; /*<>*/ var - /*<>*/ _ay_ = - /*<>*/ caml_call2(Stdlib[28], _ax_, _av_), - /*<>*/ _az_ = + /*<>*/ _aw_ = + /*<>*/ caml_call2(Stdlib[28], _av_, _at_), + /*<>*/ _ax_ = /*<>*/ caml_call2 (Stdlib_List[20], quote, [0, cmd, args]), - /*<>*/ _aA_ = - /*<>*/ caml_call2(Stdlib_String[7], cst$1, _az_); + /*<>*/ _ay_ = + /*<>*/ caml_call2(Stdlib_String[7], cst$1, _ax_); /*<>*/ return /*<>*/ caml_call2 - (Stdlib[28], _aA_, _ay_); + (Stdlib[28], _ay_, _aw_); /*<>*/ } - /*<>*/ function basename(_aq_){ - /*<>*/ return generic_basename(is_dir_sep, current_dir_name, _aq_); + /*<>*/ function basename(_ao_){ + /*<>*/ return generic_basename(is_dir_sep, current_dir_name, _ao_); } - /*<>*/ function dirname(_ap_){ - /*<>*/ return generic_dirname(is_dir_sep, current_dir_name, _ap_); + /*<>*/ function dirname(_an_){ + /*<>*/ return generic_dirname(is_dir_sep, current_dir_name, _an_); } /*<>*/ /*<>*/ var Unix = @@ -32751,96 +32839,96 @@ /*<>*/ var /*<>*/ c = /*<>*/ caml_string_get(s, i), - _am_ = 47 === c ? 1 : 0; - if(_am_) - var _an_ = _am_; + _ak_ = 47 === c ? 1 : 0; + if(_ak_) + var _al_ = _ak_; else - var _ao_ = 92 === c ? 1 : 0, _an_ = _ao_ || (58 === c ? 1 : 0); - return _an_; + var _am_ = 92 === c ? 1 : 0, _al_ = _am_ || (58 === c ? 1 : 0); + return _al_; /*<>*/ } function is_relative$0(n){ /*<>*/ var - _ag_ = caml_ml_string_length(n) < 1 ? 1 : 0, - _ah_ = - _ag_ + _ae_ = caml_ml_string_length(n) < 1 ? 1 : 0, + _af_ = + _ae_ || (47 !== /*<>*/ caml_string_get(n, 0) ? 1 : 0); - if(_ah_){ + if(_af_){ var - _ai_ = caml_ml_string_length(n) < 1 ? 1 : 0, - _aj_ = - _ai_ + _ag_ = caml_ml_string_length(n) < 1 ? 1 : 0, + _ah_ = + _ag_ || (92 !== /*<>*/ caml_string_get(n, 0) ? 1 : 0); - if(_aj_) + if(_ah_) var - _ak_ = caml_ml_string_length(n) < 2 ? 1 : 0, - _al_ = - _ak_ + _ai_ = caml_ml_string_length(n) < 2 ? 1 : 0, + _aj_ = + _ai_ || (58 !== /*<>*/ caml_string_get(n, 1) ? 1 : 0); else - var _al_ = _aj_; + var _aj_ = _ah_; } else - var _al_ = _ah_; - return _al_; + var _aj_ = _af_; + return _aj_; /*<>*/ } function is_implicit$0(n){ /*<>*/ /*<>*/ var - _Z_ = is_relative$0(n); - /*<>*/ if(_Z_){ + _X_ = is_relative$0(n); + /*<>*/ if(_X_){ var - ___ = caml_ml_string_length(n) < 2 ? 1 : 0, - _$_ = - ___ + _Y_ = caml_ml_string_length(n) < 2 ? 1 : 0, + _Z_ = + _Y_ || /*<>*/ caml_string_notequal ( /*<>*/ caml_call3(Stdlib_String[16], n, 0, 2), cst$27); - /*<>*/ if(_$_){ + /*<>*/ if(_Z_){ var - _aa_ = caml_ml_string_length(n) < 2 ? 1 : 0, - _ab_ = - _aa_ + ___ = caml_ml_string_length(n) < 2 ? 1 : 0, + _$_ = + ___ || /*<>*/ caml_string_notequal ( /*<>*/ caml_call3(Stdlib_String[16], n, 0, 2), ".\\"); - /*<>*/ if(_ab_){ + /*<>*/ if(_$_){ var - _ac_ = caml_ml_string_length(n) < 3 ? 1 : 0, - _ad_ = - _ac_ + _aa_ = caml_ml_string_length(n) < 3 ? 1 : 0, + _ab_ = + _aa_ || /*<>*/ caml_string_notequal ( /*<>*/ caml_call3 (Stdlib_String[16], n, 0, 3), cst$28); - /*<>*/ if(_ad_) + /*<>*/ if(_ab_) var - _ae_ = caml_ml_string_length(n) < 3 ? 1 : 0, - _af_ = - _ae_ + _ac_ = caml_ml_string_length(n) < 3 ? 1 : 0, + _ad_ = + _ac_ || /*<>*/ caml_string_notequal ( /*<>*/ caml_call3 (Stdlib_String[16], n, 0, 3), "..\\"); else - var _af_ = _ad_; + var _ad_ = _ab_; } else - var _af_ = _ab_; + var _ad_ = _$_; } else - var _af_ = _$_; + var _ad_ = _Z_; } else - var _af_ = _Z_; - /*<>*/ return _af_; + var _ad_ = _X_; + /*<>*/ return _ad_; /*<>*/ } function check_suffix$0(name, suff){ /*<>*/ var - _W_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0; - if(_W_) + _U_ = caml_ml_string_length(suff) <= caml_ml_string_length(name) ? 1 : 0; + if(_U_) /*<>*/ var /*<>*/ s = /*<>*/ caml_call3 @@ -32848,14 +32936,14 @@ name, caml_ml_string_length(name) - caml_ml_string_length(suff) | 0, caml_ml_string_length(suff)), - /*<>*/ _X_ = + /*<>*/ _V_ = /*<>*/ caml_call1(Stdlib_String[27], suff), - _Y_ = + _W_ = /*<>*/ caml_string_equal - ( /*<>*/ caml_call1(Stdlib_String[27], s), _X_); + ( /*<>*/ caml_call1(Stdlib_String[27], s), _V_); else - var _Y_ = _W_; - /*<>*/ return _Y_; + var _W_ = _U_; + /*<>*/ return _W_; /*<>*/ } function chop_suffix_opt$0(suffix, filename){ /*<>*/ var @@ -32866,11 +32954,11 @@ /*<>*/ r = /*<>*/ caml_call3 (Stdlib_String[16], filename, len_f - len_s | 0, len_s), - /*<>*/ _V_ = + /*<>*/ _T_ = /*<>*/ caml_call1(Stdlib_String[27], suffix); /*<>*/ return /*<>*/ caml_string_equal ( /*<>*/ caml_call1(Stdlib_String[27], r), - _V_) + _T_) ? [0, /*<>*/ caml_call3 (Stdlib_String[16], filename, 0, len_f - len_s | 0)] @@ -32882,8 +32970,8 @@ /*<>*/ caml_sys_getenv("TEMP"), temp_dir_name$0 = _k_; } - catch(_U_){ - var _b_ = caml_wrap_exception(_U_); + catch(_S_){ + var _b_ = caml_wrap_exception(_S_); if(_b_ !== Stdlib[8]) throw caml_maybe_attach_backtrace(_b_, 0); var temp_dir_name$0 = cst$5; } @@ -32894,44 +32982,23 @@ /*<>*/ caml_call1(Stdlib_Buffer[1], l + 20 | 0); /*<>*/ /*<>*/ caml_call2 (Stdlib_Buffer[12], b, 34); - function add_bs(n){ - /*<>*/ /*<>*/ var _S_ = 1; - if(n >= 1){ - var j = _S_; - for(;;){ - /*<>*/ /*<>*/ caml_call2 - (Stdlib_Buffer[12], b, 92); - /*<>*/ /*<>*/ var - _T_ = j + 1 | 0; - if(n === j) break; - var j = _T_; - } - } - return 0; - /*<>*/ } - function loop$0(counter, i){ + function loop(i){ /*<>*/ var i$0 = i; /*<>*/ for(;;){ - if(i$0 === l) - /*<>*/ return /*<>*/ caml_call2 - (Stdlib_Buffer[12], b, 34); + if(i$0 === l){ + /*<>*/ /*<>*/ caml_call2 + (Stdlib_Buffer[12], b, 34); + /*<>*/ return; + } /*<>*/ /*<>*/ var c = /*<>*/ caml_string_get(s, i$0); if(34 === c){ - var _Q_ = 0; - /*<>*/ if(counter >= 50) - /*<>*/ return /*<>*/ caml_trampoline_return - (loop_bs, [0, _Q_, i$0]); - var counter$1 = counter + 1 | 0; - /*<>*/ return loop_bs(counter$1, _Q_, i$0); + /*<>*/ loop_bs(0, i$0); + /*<>*/ return; } if(92 === c){ - var _R_ = 0; - /*<>*/ if(counter >= 50) - /*<>*/ return /*<>*/ caml_trampoline_return - (loop_bs, [0, _R_, i$0]); - var counter$0 = counter + 1 | 0; - /*<>*/ return loop_bs(counter$0, _R_, i$0); + /*<>*/ loop_bs(0, i$0); + /*<>*/ return; } /*<>*/ /*<>*/ caml_call2 (Stdlib_Buffer[12], b, c); @@ -32940,13 +33007,14 @@ i$0 = i$1; } /*<>*/ } - function loop_bs(counter, n, i){ + function loop_bs(n, i){ /*<>*/ var n$0 = n, i$0 = i; /*<>*/ for(;;){ if(i$0 === l){ /*<>*/ /*<>*/ caml_call2 (Stdlib_Buffer[12], b, 34); - /*<>*/ return add_bs(n$0); + /*<>*/ add_bs(n$0); + /*<>*/ return; } /*<>*/ /*<>*/ var match = /*<>*/ caml_string_get(s, i$0); @@ -32954,21 +33022,13 @@ /*<>*/ add_bs((2 * n$0 | 0) + 1 | 0); /*<>*/ /*<>*/ caml_call2 (Stdlib_Buffer[12], b, 34); - /*<>*/ /*<>*/ var - _P_ = i$0 + 1 | 0; - /*<>*/ if(counter >= 50) - /*<>*/ return /*<>*/ caml_trampoline_return - (loop$0, [0, _P_]); - var counter$1 = counter + 1 | 0; - /*<>*/ return loop$0(counter$1, _P_); + /*<>*/ loop(i$0 + 1 | 0); + /*<>*/ return; } if(92 !== match){ /*<>*/ add_bs(n$0); - /*<>*/ if(counter >= 50) - /*<>*/ return /*<>*/ caml_trampoline_return - (loop$0, [0, i$0]); - var counter$0 = counter + 1 | 0; - /*<>*/ return loop$0(counter$0, i$0); + /*<>*/ loop(i$0); + /*<>*/ return; } /*<>*/ var /*<>*/ i$1 = i$0 + 1 | 0, @@ -32977,76 +33037,90 @@ i$0 = i$1; } /*<>*/ } - function loop(i){ /*<>*/ return caml_trampoline(loop$0(0, i));} + function add_bs(n){ + /*<>*/ /*<>*/ var _Q_ = 1; + if(n >= 1){ + var j = _Q_; + for(;;){ + /*<>*/ /*<>*/ caml_call2 + (Stdlib_Buffer[12], b, 92); + /*<>*/ /*<>*/ var + _R_ = j + 1 | 0; + if(n === j) break; + var j = _R_; + } + } + return; + /*<>*/ } /*<>*/ loop(0); /*<>*/ return /*<>*/ caml_call1 (Stdlib_Buffer[2], b); /*<>*/ } function quote_cmd_filename(f){ - function _N_(param){ + function _O_(param){ /*<>*/ if(34 !== param && 37 !== param) /*<>*/ return 0; /*<>*/ return 1; /*<>*/ } /*<>*/ if - (! /*<>*/ caml_call2(Stdlib_String[23], _N_, f)) + (! /*<>*/ caml_call2(Stdlib_String[23], _O_, f)) /*<>*/ return /*<>*/ caml_call2 (Stdlib_String[15], f, 32) ? /*<>*/ caml_call2 (Stdlib_String[7], cst$7, [0, cst$6, [0, f, _c_]]) : f; /*<>*/ /*<>*/ var - _O_ = + _P_ = /*<>*/ caml_call2 (Stdlib[28], cst_Filename_quote_command_bad, f); /*<>*/ return /*<>*/ caml_call1 - (Stdlib[2], _O_); + (Stdlib[2], _P_); /*<>*/ } function quote_command$0(cmd, stdin, stdout, stderr, args){ /*<>*/ if(stderr){ var f = stderr[1]; /*<>*/ if ( /*<>*/ caml_equal(stderr, stdout)) - var _z_ = cst_2_1$0; + var _A_ = cst_2_1$0; else /*<>*/ var - /*<>*/ _L_ = quote_cmd_filename(f), - _z_ = /*<>*/ caml_call2(Stdlib[28], cst_2$0, _L_); - var _A_ = _z_; + /*<>*/ _M_ = quote_cmd_filename(f), + _A_ = /*<>*/ caml_call2(Stdlib[28], cst_2$0, _M_); + var _B_ = _A_; } else - var _A_ = cst$16; - var _B_ = [0, _A_, _d_]; + var _B_ = cst$16; + var _C_ = [0, _B_, _d_]; if(stdout) /*<>*/ var f$0 = stdout[1], - /*<>*/ _C_ = quote_cmd_filename(f$0), - _D_ = /*<>*/ caml_call2(Stdlib[28], cst$8, _C_); + /*<>*/ _D_ = quote_cmd_filename(f$0), + _E_ = /*<>*/ caml_call2(Stdlib[28], cst$8, _D_); else - var _D_ = cst$15; - var _E_ = [0, _D_, _B_]; + var _E_ = cst$15; + var _F_ = [0, _E_, _C_]; if(stdin) /*<>*/ var f$1 = stdin[1], - /*<>*/ _F_ = quote_cmd_filename(f$1), - _G_ = /*<>*/ caml_call2(Stdlib[28], cst$9, _F_); + /*<>*/ _G_ = quote_cmd_filename(f$1), + _H_ = /*<>*/ caml_call2(Stdlib[28], cst$9, _G_); else - var _G_ = cst$14; + var _H_ = cst$14; /*<>*/ var - /*<>*/ _I_ = + /*<>*/ _J_ = /*<>*/ caml_call2(Stdlib_List[20], quote$0, args), /*<>*/ s = - /*<>*/ caml_call2(Stdlib_String[7], cst$10, _I_), + /*<>*/ caml_call2(Stdlib_String[7], cst$10, _J_), /*<>*/ b = /*<>*/ caml_call1 (Stdlib_Buffer[1], caml_ml_string_length(s) + 20 | 0), - _H_ = [0, _G_, _E_]; - function _y_(c){ + _I_ = [0, _H_, _F_]; + function _z_(c){ /*<>*/ a: { if(62 <= c){ - var _M_ = c - 63 | 0; - if(60 < _M_ >>> 0){if(62 <= _M_) break a;} else if(31 !== _M_) break a; + var _N_ = c - 63 | 0; + if(60 < _N_ >>> 0){if(62 <= _N_) break a;} else if(31 !== _N_) break a; } else if(42 <= c){ @@ -33066,21 +33140,21 @@ (Stdlib_Buffer[12], b, c); /*<>*/ } /*<>*/ /*<>*/ caml_call2 - (Stdlib_String[30], _y_, s); + (Stdlib_String[30], _z_, s); /*<>*/ var - _J_ = + _K_ = [0, cst$11, - [0, /*<>*/ caml_call1(Stdlib_Buffer[2], b), _H_]], - /*<>*/ _K_ = - [0, cst$12, [0, quote_cmd_filename(cmd), _J_]]; + [0, /*<>*/ caml_call1(Stdlib_Buffer[2], b), _I_]], + /*<>*/ _L_ = + [0, cst$12, [0, quote_cmd_filename(cmd), _K_]]; /*<>*/ return /*<>*/ caml_call2 - (Stdlib_String[7], cst$13, _K_); + (Stdlib_String[7], cst$13, _L_); /*<>*/ } function drive_and_path(s){ /*<>*/ var - _u_ = 2 <= /*<>*/ caml_ml_string_length(s) ? 1 : 0; - if(_u_){ + _v_ = 2 <= /*<>*/ caml_ml_string_length(s) ? 1 : 0; + if(_v_){ /*<>*/ /*<>*/ var param = /*<>*/ caml_string_get(s, 0); a: @@ -33091,28 +33165,28 @@ if(25 < param - 97 >>> 0) break b; } else if(65 > param) break b; - var _v_ = 1; + var _w_ = 1; break a; } - var _v_ = 0; + var _w_ = 0; } /*<>*/ /*<>*/ var - _w_ = - _v_ + _x_ = + _w_ ? 58 === /*<>*/ caml_string_get(s, 1) ? 1 : 0 - : _v_; + : _w_; } else - var _w_ = _u_; - /*<>*/ if(! _w_) + var _x_ = _v_; + /*<>*/ if(! _x_) /*<>*/ return [0, cst$17, s]; /*<>*/ /*<>*/ var - _x_ = + _y_ = /*<>*/ caml_call3 (Stdlib_String[16], s, 2, caml_ml_string_length(s) - 2 | 0); /*<>*/ return [0, /*<>*/ caml_call3(Stdlib_String[16], s, 0, 2), - _x_]; + _y_]; /*<>*/ } function dirname$0(s){ /*<>*/ var @@ -33146,11 +33220,11 @@ quote_command$0, basename$0, dirname$0]; - /*<>*/ function basename$1(_t_){ - /*<>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _t_); + /*<>*/ function basename$1(_u_){ + /*<>*/ return generic_basename(is_dir_sep$0, current_dir_name$1, _u_); } - /*<>*/ function dirname$1(_s_){ - /*<>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _s_); + /*<>*/ function dirname$1(_t_){ + /*<>*/ return generic_dirname(is_dir_sep$0, current_dir_name$1, _t_); } /*<>*/ var /*<>*/ Cygwin = @@ -33193,11 +33267,11 @@ /*<>*/ if (0 !== l && ! is_dir_sep$1(dirname, l - 1 | 0)){ /*<>*/ /*<>*/ var - _r_ = + _s_ = /*<>*/ caml_call2 (Stdlib[28], dir_sep$2, filename); /*<>*/ return /*<>*/ caml_call2 - (Stdlib[28], dirname, _r_); + (Stdlib[28], dirname, _s_); } /*<>*/ return /*<>*/ caml_call2 (Stdlib[28], dirname, filename); @@ -33300,7 +33374,7 @@ /*<>*/ } /*<>*/ var /*<>*/ _h_ = - [0, function(_q_){ /*<>*/ return _q_;}], + [0, function(_r_){ /*<>*/ return _r_;}], /*<>*/ current_temp_dir_name = /*<>*/ caml_call2(Stdlib_Domain[10][1], _h_, _g_); function set_temp_dir_name(s){ @@ -33340,17 +33414,17 @@ } } /*<>*/ } - function open_temp_file(opt, _o_, _n_, prefix, suffix){ + function open_temp_file(opt, _p_, _o_, prefix, suffix){ /*<>*/ if(opt) var sth = opt[1], mode = sth; else var mode = _j_; - /*<>*/ if(_o_) - var sth$0 = _o_[1], perms = sth$0; + /*<>*/ if(_p_) + var sth$0 = _p_[1], perms = sth$0; else var perms = 384; - /*<>*/ if(_n_) - var sth$1 = _n_[1], temp_dir = sth$1; + /*<>*/ if(_o_) + var sth$1 = _o_[1], temp_dir = sth$1; else var temp_dir = @@ -33362,12 +33436,12 @@ name = temp_file_name(temp_dir, prefix, suffix); /*<>*/ try{ /*<>*/ /*<>*/ var - _p_ = + _q_ = [0, name, /*<>*/ caml_call3 (Stdlib[62], [0, 1, [0, 3, [0, 5, mode]]], perms, name)]; - /*<>*/ return _p_; + /*<>*/ return _q_; } catch(e$0){ var e = caml_wrap_exception(e$0); @@ -33381,7 +33455,7 @@ } } /*<>*/ } - function temp_dir(opt, _m_, prefix, suffix){ + function temp_dir(opt, _n_, prefix, suffix){ /*<>*/ if(opt) var sth = opt[1], temp_dir = sth; else @@ -33389,8 +33463,8 @@ temp_dir = /*<>*/ caml_call1 (Stdlib_Domain[10][2], current_temp_dir_name); - /*<>*/ if(_m_) - var sth$0 = _m_[1], perms = sth$0; + /*<>*/ if(_n_) + var sth$0 = _n_[1], perms = sth$0; else var perms = 448; var counter = 0; diff --git a/manual/options.wiki b/manual/options.wiki index f5af01bb05..b8cc16db16 100644 --- a/manual/options.wiki +++ b/manual/options.wiki @@ -32,18 +32,19 @@ various optimizations until a fix-point is reached ==List of option to "--disable" or "--enable" -|= Option name |= Default |= Description | -| pretty | false | Pretty print the javascript output | -| effects | false | Enable support for effect handlers | -| debuginfo | false | Output debug information (location) | -| deadcode | true | Deadcode elimination | -| inline | true | Code inlining | -| shortvar | true | Shorten variable names | -| staticeval | true | Static evaluation of constants | -| share | true | Share string and number constants | -| strict | true | Enable strict mode | -| debugger | true | Keep debugger statements. - Stripped otherwise | -| genprim | true | Generate dummy primitives when missing | -| excwrap | true | Wrap js exception into ocaml ones | -| optcall | true | Javascript optimizations | +|= Option name |= Default |= Description | +| pretty | false | Pretty print the javascript output | +| effects | false | Enable support for effect handlers | +| debuginfo | false | Output debug information (location) | +| deadcode | true | Deadcode elimination | +| glboaldeadcode | true | Global deadcode elimination | +| inline | true | Code inlining | +| shortvar | true | Shorten variable names | +| staticeval | true | Static evaluation of constants | +| share | true | Share string and number constants | +| strict | true | Enable strict mode | +| debugger | true | Keep debugger statements. + Stripped otherwise | +| genprim | true | Generate dummy primitives when missing | +| excwrap | true | Wrap js exception into ocaml ones | +| optcall | true | Javascript optimizations |