5d329c102f3113aa525b0fc7cf5fa3dd89647c59
[WebKit-https.git] / JSTests / wasm / spec-harness / wast.js
1 // DO NOT EDIT. Generated from WebAssembly spec interpreter
2
3 let WebAssemblyText = (function() {
4   let _registry = {__proto__: null};
5   function normalize(file) {
6     return file.split('/').reverse()[0].split('.')[0];
7   }
8   function require(file) {
9     let name = normalize(file);
10     if (!(name in _registry)) {
11       throw new Error('missing module: ' + name)
12     } else if (typeof _registry[name] === 'function') {
13
14
15       let f = _registry[name];
16       _registry[name] = function() { throw new Error('cyclic module: ' + name) };
17       _registry[name] = f();
18     }
19     return _registry[name];
20   }
21
22
23   _registry['arrange'] = function() {
24     let exports = {};
25 //////// start of arrange.js ////////
26 // Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
27 'use strict';
28
29 var F32                     = require("./f32");
30 var F64                     = require("./f64");
31 var I32                     = require("./i32");
32 var I64                     = require("./i64");
33 var Lib                     = require("./lib");
34 var List                    = require("bs-platform/lib/js/list");
35 var Block                   = require("bs-platform/lib/js/block");
36 var Curry                   = require("bs-platform/lib/js/curry");
37 var Types                   = require("./types");
38 var Buffer                  = require("bs-platform/lib/js/buffer");
39 var Decode                  = require("./decode");
40 var Encode                  = require("./encode");
41 var Printf                  = require("bs-platform/lib/js/printf");
42 var Source                  = require("./source");
43 var $$String                = require("bs-platform/lib/js/string");
44 var Values                  = require("./values");
45 var Caml_int32              = require("bs-platform/lib/js/caml_int32");
46 var Pervasives              = require("bs-platform/lib/js/pervasives");
47 var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions");
48
49 function add_hex_char(buf, c) {
50   return Curry._1(Printf.bprintf(buf, /* Format */[
51                   /* Char_literal */Block.__(12, [
52                       /* "\\" */92,
53                       /* Int */Block.__(4, [
54                           /* Int_x */6,
55                           /* Lit_padding */Block.__(0, [
56                               /* Zeros */2,
57                               2
58                             ]),
59                           /* No_precision */0,
60                           /* End_of_format */0
61                         ])
62                     ]),
63                   "\\%02x"
64                 ]), c);
65 }
66
67 function add_char(buf, c) {
68   if (c < /* " " */32 || c >= /* "\127" */127) {
69     return add_hex_char(buf, c);
70   }
71   else {
72     if (c === /* "\"" */34 || c === /* "\\" */92) {
73       Buffer.add_char(buf, /* "\\" */92);
74     }
75     return Buffer.add_char(buf, c);
76   }
77 }
78
79 function string_with(add_char, s) {
80   var buf = Buffer.create(Caml_int32.imul(3, s.length) + 2 | 0);
81   Buffer.add_char(buf, /* "\"" */34);
82   $$String.iter(Curry._1(add_char, buf), s);
83   Buffer.add_char(buf, /* "\"" */34);
84   return Buffer.contents(buf);
85 }
86
87 function list_of_opt(param) {
88   if (param) {
89     return /* :: */[
90             param[0],
91             /* [] */0
92           ];
93   }
94   else {
95     return /* [] */0;
96   }
97 }
98
99 function break_bytes(s) {
100   var ss = Curry._2(Lib.$$String[/* breakup */0], s, 16);
101   var f = function (param) {
102     return /* Atom */Block.__(0, [string_with(add_hex_char, param)]);
103   };
104   return List.map(f, ss);
105 }
106
107 function decls(kind, ts) {
108   var head = kind;
109   var f = function (param) {
110     return /* Atom */Block.__(0, [Types.string_of_value_type(param)]);
111   };
112   var xs = ts;
113   if (xs) {
114     return /* :: */[
115             /* Node */Block.__(1, [
116                 head,
117                 List.map(f, xs)
118               ]),
119             /* [] */0
120           ];
121   }
122   else {
123     return /* [] */0;
124   }
125 }
126
127 function func_type(param) {
128   return /* Node */Block.__(1, [
129             "func",
130             Pervasives.$at(decls("param", param[0]), decls("result", param[1]))
131           ]);
132 }
133
134 function limits(nat, param) {
135   var xs = list_of_opt(param[/* max */1]);
136   return $$String.concat(" ", /* :: */[
137               Curry._1(nat, param[/* min */0]),
138               List.map(nat, xs)
139             ]);
140 }
141
142 function global_type(param) {
143   var t = param[0];
144   if (param[1] !== 0) {
145     return /* Node */Block.__(1, [
146               "mut",
147               /* :: */[
148                 /* Atom */Block.__(0, [Types.string_of_value_type(t)]),
149                 /* [] */0
150               ]
151             ]);
152   }
153   else {
154     return /* Atom */Block.__(0, [Types.string_of_value_type(t)]);
155   }
156 }
157
158 function testop(_, _$1) {
159   return "eqz";
160 }
161
162 function relop(_, param) {
163   switch (param) {
164     case 0 : 
165         return "eq";
166     case 1 : 
167         return "ne";
168     case 2 : 
169         return "lt_s";
170     case 3 : 
171         return "lt_u";
172     case 4 : 
173         return "gt_s";
174     case 5 : 
175         return "gt_u";
176     case 6 : 
177         return "le_s";
178     case 7 : 
179         return "le_u";
180     case 8 : 
181         return "ge_s";
182     case 9 : 
183         return "ge_u";
184     
185   }
186 }
187
188 function unop(_, param) {
189   switch (param) {
190     case 0 : 
191         return "clz";
192     case 1 : 
193         return "ctz";
194     case 2 : 
195         return "popcnt";
196     
197   }
198 }
199
200 function binop(_, param) {
201   switch (param) {
202     case 0 : 
203         return "add";
204     case 1 : 
205         return "sub";
206     case 2 : 
207         return "mul";
208     case 3 : 
209         return "div_s";
210     case 4 : 
211         return "div_u";
212     case 5 : 
213         return "rem_s";
214     case 6 : 
215         return "rem_u";
216     case 7 : 
217         return "and";
218     case 8 : 
219         return "or";
220     case 9 : 
221         return "xor";
222     case 10 : 
223         return "shl";
224     case 11 : 
225         return "shr_s";
226     case 12 : 
227         return "shr_u";
228     case 13 : 
229         return "rotl";
230     case 14 : 
231         return "rotr";
232     
233   }
234 }
235
236 function cvtop(xx, param) {
237   switch (param) {
238     case 0 : 
239         return "extend_s/i32";
240     case 1 : 
241         return "extend_u/i32";
242     case 2 : 
243         return "wrap/i64";
244     case 3 : 
245         return "trunc_s/f32";
246     case 4 : 
247         return "trunc_u/f32";
248     case 5 : 
249         return "trunc_s/f64";
250     case 6 : 
251         return "trunc_u/f64";
252     case 7 : 
253         return "reinterpret/f" + xx;
254     
255   }
256 }
257
258 function testop$1(_, _$1) {
259   throw [
260         Caml_builtin_exceptions.assert_failure,
261         [
262           "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/arrange.ml",
263           128,
264           27
265         ]
266       ];
267 }
268
269 function relop$1(_, param) {
270   switch (param) {
271     case 0 : 
272         return "eq";
273     case 1 : 
274         return "ne";
275     case 2 : 
276         return "lt";
277     case 3 : 
278         return "gt";
279     case 4 : 
280         return "le";
281     case 5 : 
282         return "ge";
283     
284   }
285 }
286
287 function unop$1(_, param) {
288   switch (param) {
289     case 0 : 
290         return "neg";
291     case 1 : 
292         return "abs";
293     case 2 : 
294         return "ceil";
295     case 3 : 
296         return "floor";
297     case 4 : 
298         return "trunc";
299     case 5 : 
300         return "nearest";
301     case 6 : 
302         return "sqrt";
303     
304   }
305 }
306
307 function binop$1(_, param) {
308   switch (param) {
309     case 0 : 
310         return "add";
311     case 1 : 
312         return "sub";
313     case 2 : 
314         return "mul";
315     case 3 : 
316         return "div";
317     case 4 : 
318         return "min";
319     case 5 : 
320         return "max";
321     case 6 : 
322         return "copysign";
323     
324   }
325 }
326
327 function cvtop$1(xx, param) {
328   switch (param) {
329     case 0 : 
330         return "convert_s/i32";
331     case 1 : 
332         return "convert_u/i32";
333     case 2 : 
334         return "convert_s/i64";
335     case 3 : 
336         return "convert_u/i64";
337     case 4 : 
338         return "promote/f32";
339     case 5 : 
340         return "demote/f64";
341     case 6 : 
342         return "reinterpret/i" + xx;
343     
344   }
345 }
346
347 function oper(param, op) {
348   var floatop = param[1];
349   var intop = param[0];
350   var $js;
351   switch (op.tag | 0) {
352     case 0 : 
353         $js = Curry._2(intop, "32", op[0]);
354         break;
355     case 1 : 
356         $js = Curry._2(intop, "64", op[0]);
357         break;
358     case 2 : 
359         $js = Curry._2(floatop, "32", op[0]);
360         break;
361     case 3 : 
362         $js = Curry._2(floatop, "64", op[0]);
363         break;
364     
365   }
366   return Types.string_of_value_type(Values.type_of(op)) + ("." + $js);
367 }
368
369 var partial_arg = /* tuple */[
370   unop,
371   unop$1
372 ];
373
374 function unop$2(param) {
375   return oper(partial_arg, param);
376 }
377
378 var partial_arg$1 = /* tuple */[
379   binop,
380   binop$1
381 ];
382
383 function binop$2(param) {
384   return oper(partial_arg$1, param);
385 }
386
387 var partial_arg$2 = /* tuple */[
388   testop,
389   testop$1
390 ];
391
392 function testop$2(param) {
393   return oper(partial_arg$2, param);
394 }
395
396 var partial_arg$3 = /* tuple */[
397   relop,
398   relop$1
399 ];
400
401 function relop$2(param) {
402   return oper(partial_arg$3, param);
403 }
404
405 var partial_arg$4 = /* tuple */[
406   cvtop,
407   cvtop$1
408 ];
409
410 function cvtop$2(param) {
411   return oper(partial_arg$4, param);
412 }
413
414 function mem_size(param) {
415   switch (param) {
416     case 0 : 
417         return "8";
418     case 1 : 
419         return "16";
420     case 2 : 
421         return "32";
422     
423   }
424 }
425
426 function extension(param) {
427   if (param !== 0) {
428     return "_u";
429   }
430   else {
431     return "_s";
432   }
433 }
434
435 function memop(name, param) {
436   var offset = param[/* offset */2];
437   var align = param[/* align */1];
438   var ty = param[/* ty */0];
439   return Types.string_of_value_type(ty) + ("." + (name + ((
440                 offset ? " offset=" + Curry._1(I32.to_string_u, offset) : ""
441               ) + (
442                 (1 << align) === Types.size(ty) ? "" : " align=" + Curry._1(I32.to_string_u, Curry._1(I32.of_int_u, (1 << align)))
443               ))));
444 }
445
446 function loadop(op) {
447   var match = op[/* sz */3];
448   if (match) {
449     var match$1 = match[0];
450     return memop("load" + (mem_size(match$1[0]) + extension(match$1[1])), op);
451   }
452   else {
453     return memop("load", op);
454   }
455 }
456
457 function storeop(op) {
458   var match = op[/* sz */3];
459   if (match) {
460     return memop("store" + mem_size(match[0]), op);
461   }
462   else {
463     return memop("store", op);
464   }
465 }
466
467 function $$var(x) {
468   return Curry._1(I32.to_string_u, x[/* it */1]);
469 }
470
471 function constop(v) {
472   return Types.string_of_value_type(Values.type_of(v[/* it */1])) + ".const";
473 }
474
475 function instr(e) {
476   var match = e[/* it */1];
477   var match$1;
478   if (typeof match === "number") {
479     switch (match) {
480       case 0 : 
481           match$1 = /* tuple */[
482             "unreachable",
483             /* [] */0
484           ];
485           break;
486       case 1 : 
487           match$1 = /* tuple */[
488             "nop",
489             /* [] */0
490           ];
491           break;
492       case 2 : 
493           match$1 = /* tuple */[
494             "return",
495             /* [] */0
496           ];
497           break;
498       case 3 : 
499           match$1 = /* tuple */[
500             "drop",
501             /* [] */0
502           ];
503           break;
504       case 4 : 
505           match$1 = /* tuple */[
506             "select",
507             /* [] */0
508           ];
509           break;
510       case 5 : 
511           match$1 = /* tuple */[
512             "current_memory",
513             /* [] */0
514           ];
515           break;
516       case 6 : 
517           match$1 = /* tuple */[
518             "grow_memory",
519             /* [] */0
520           ];
521           break;
522       
523     }
524   }
525   else {
526     switch (match.tag | 0) {
527       case 0 : 
528           var f = function (param) {
529             return /* Atom */Block.__(0, [Types.string_of_value_type(param)]);
530           };
531           match$1 = /* tuple */[
532             "block",
533             Pervasives.$at(List.map(f, match[0]), List.map(instr, match[1]))
534           ];
535           break;
536       case 1 : 
537           var f$1 = function (param) {
538             return /* Atom */Block.__(0, [Types.string_of_value_type(param)]);
539           };
540           match$1 = /* tuple */[
541             "loop",
542             Pervasives.$at(List.map(f$1, match[0]), List.map(instr, match[1]))
543           ];
544           break;
545       case 2 : 
546           var f$2 = function (param) {
547             return /* Atom */Block.__(0, [Types.string_of_value_type(param)]);
548           };
549           match$1 = /* tuple */[
550             "if",
551             Pervasives.$at(List.map(f$2, match[0]), /* :: */[
552                   /* Node */Block.__(1, [
553                       "then",
554                       List.map(instr, match[1])
555                     ]),
556                   /* :: */[
557                     /* Node */Block.__(1, [
558                         "else",
559                         List.map(instr, match[2])
560                       ]),
561                     /* [] */0
562                   ]
563                 ])
564           ];
565           break;
566       case 3 : 
567           match$1 = /* tuple */[
568             "br " + Curry._1(I32.to_string_u, match[0][/* it */1]),
569             /* [] */0
570           ];
571           break;
572       case 4 : 
573           match$1 = /* tuple */[
574             "br_if " + Curry._1(I32.to_string_u, match[0][/* it */1]),
575             /* [] */0
576           ];
577           break;
578       case 5 : 
579           var xs = Pervasives.$at(match[0], /* :: */[
580                 match[1],
581                 /* [] */0
582               ]);
583           match$1 = /* tuple */[
584             "br_table " + $$String.concat(" ", List.map($$var, xs)),
585             /* [] */0
586           ];
587           break;
588       case 6 : 
589           match$1 = /* tuple */[
590             "call " + Curry._1(I32.to_string_u, match[0][/* it */1]),
591             /* [] */0
592           ];
593           break;
594       case 7 : 
595           match$1 = /* tuple */[
596             "call_indirect " + Curry._1(I32.to_string_u, match[0][/* it */1]),
597             /* [] */0
598           ];
599           break;
600       case 8 : 
601           match$1 = /* tuple */[
602             "get_local " + Curry._1(I32.to_string_u, match[0][/* it */1]),
603             /* [] */0
604           ];
605           break;
606       case 9 : 
607           match$1 = /* tuple */[
608             "set_local " + Curry._1(I32.to_string_u, match[0][/* it */1]),
609             /* [] */0
610           ];
611           break;
612       case 10 : 
613           match$1 = /* tuple */[
614             "tee_local " + Curry._1(I32.to_string_u, match[0][/* it */1]),
615             /* [] */0
616           ];
617           break;
618       case 11 : 
619           match$1 = /* tuple */[
620             "get_global " + Curry._1(I32.to_string_u, match[0][/* it */1]),
621             /* [] */0
622           ];
623           break;
624       case 12 : 
625           match$1 = /* tuple */[
626             "set_global " + Curry._1(I32.to_string_u, match[0][/* it */1]),
627             /* [] */0
628           ];
629           break;
630       case 13 : 
631           match$1 = /* tuple */[
632             loadop(match[0]),
633             /* [] */0
634           ];
635           break;
636       case 14 : 
637           match$1 = /* tuple */[
638             storeop(match[0]),
639             /* [] */0
640           ];
641           break;
642       case 15 : 
643           var lit = match[0];
644           match$1 = /* tuple */[
645             constop(lit) + (" " + Values.string_of_value(lit[/* it */1])),
646             /* [] */0
647           ];
648           break;
649       case 16 : 
650           match$1 = /* tuple */[
651             Curry._1(testop$2, match[0]),
652             /* [] */0
653           ];
654           break;
655       case 17 : 
656           match$1 = /* tuple */[
657             Curry._1(relop$2, match[0]),
658             /* [] */0
659           ];
660           break;
661       case 18 : 
662           match$1 = /* tuple */[
663             Curry._1(unop$2, match[0]),
664             /* [] */0
665           ];
666           break;
667       case 19 : 
668           match$1 = /* tuple */[
669             Curry._1(binop$2, match[0]),
670             /* [] */0
671           ];
672           break;
673       case 20 : 
674           match$1 = /* tuple */[
675             Curry._1(cvtop$2, match[0]),
676             /* [] */0
677           ];
678           break;
679       
680     }
681   }
682   return /* Node */Block.__(1, [
683             match$1[0],
684             match$1[1]
685           ]);
686 }
687
688 function func_with_name(name, f) {
689   var match = f[/* it */1];
690   return /* Node */Block.__(1, [
691             "func" + name,
692             Pervasives.$at(/* :: */[
693                   /* Node */Block.__(1, [
694                       "type " + Curry._1(I32.to_string_u, match[/* ftype */0][/* it */1]),
695                       /* [] */0
696                     ]),
697                   /* [] */0
698                 ], Pervasives.$at(decls("local", match[/* locals */1]), List.map(instr, match[/* body */2])))
699           ]);
700 }
701
702 function func(f) {
703   return func_with_name("", f);
704 }
705
706 function start(x) {
707   return /* Node */Block.__(1, [
708             "start " + Curry._1(I32.to_string_u, x[/* it */1]),
709             /* [] */0
710           ]);
711 }
712
713 function table(off, i, tab) {
714   var match = tab[/* it */1];
715   var match$1 = match[/* ttype */0];
716   return /* Node */Block.__(1, [
717             "table $" + (Curry._1(I32.to_string_u, Curry._1(I32.of_int_u, off + i | 0)) + (" " + limits(I32.to_string_u, match$1[0]))),
718             /* :: */[
719               /* Atom */Block.__(0, [Types.string_of_elem_type(match$1[1])]),
720               /* [] */0
721             ]
722           ]);
723 }
724
725 function memory(off, i, mem) {
726   var match = mem[/* it */1];
727   return /* Node */Block.__(1, [
728             "memory $" + (Curry._1(I32.to_string_u, Curry._1(I32.of_int_u, off + i | 0)) + (" " + limits(I32.to_string_u, match[/* mtype */0][0]))),
729             /* [] */0
730           ]);
731 }
732
733 function segment(head, dat, seg) {
734   var match = seg[/* it */1];
735   return /* Node */Block.__(1, [
736             head,
737             /* :: */[
738               /* Atom */Block.__(0, [Curry._1(I32.to_string_u, match[/* index */0][/* it */1])]),
739               /* :: */[
740                 /* Node */Block.__(1, [
741                     "offset",
742                     List.map(instr, match[/* offset */1][/* it */1])
743                   ]),
744                 Curry._1(dat, match[/* init */2])
745               ]
746             ]
747           ]);
748 }
749
750 function elems(seg) {
751   return segment("elem", function (param) {
752               return List.map(function (param) {
753                           return /* Atom */Block.__(0, [Curry._1(I32.to_string_u, param[/* it */1])]);
754                         }, param);
755             }, seg);
756 }
757
758 function data(seg) {
759   return segment("data", break_bytes, seg);
760 }
761
762 function typedef(i, t) {
763   return /* Node */Block.__(1, [
764             "type $" + Curry._1(I32.to_string_u, Curry._1(I32.of_int_u, i)),
765             /* :: */[
766               func_type(t),
767               /* [] */0
768             ]
769           ]);
770 }
771
772 function import_kind(i, k) {
773   var match = k[/* it */1];
774   switch (match.tag | 0) {
775     case 0 : 
776         return /* Node */Block.__(1, [
777                   "func $" + Curry._1(I32.to_string_u, Curry._1(I32.of_int_u, i)),
778                   /* :: */[
779                     /* Node */Block.__(1, [
780                         "type",
781                         /* :: */[
782                           /* Atom */Block.__(0, [Curry._1(I32.to_string_u, match[0][/* it */1])]),
783                           /* [] */0
784                         ]
785                       ]),
786                     /* [] */0
787                   ]
788                 ]);
789     case 1 : 
790         return table(0, i, Source.$at$at(/* record */[/* ttype */match[0]], k[/* at */0]));
791     case 2 : 
792         return memory(0, i, Source.$at$at(/* record */[/* mtype */match[0]], k[/* at */0]));
793     case 3 : 
794         return /* Node */Block.__(1, [
795                   "global $" + Curry._1(I32.to_string_u, Curry._1(I32.of_int_u, i)),
796                   /* :: */[
797                     global_type(match[0]),
798                     /* [] */0
799                   ]
800                 ]);
801     
802   }
803 }
804
805 function $$import(i, im) {
806   var match = im[/* it */1];
807   return /* Node */Block.__(1, [
808             "import",
809             /* :: */[
810               /* Atom */Block.__(0, [string_with(add_char, match[/* module_name */0])]),
811               /* :: */[
812                 /* Atom */Block.__(0, [string_with(add_char, match[/* item_name */1])]),
813                 /* :: */[
814                   import_kind(i, match[/* ikind */2]),
815                   /* [] */0
816                 ]
817               ]
818             ]
819           ]);
820 }
821
822 function export_kind(k) {
823   var match = k[/* it */1];
824   switch (match) {
825     case 0 : 
826         return "func";
827     case 1 : 
828         return "table";
829     case 2 : 
830         return "memory";
831     case 3 : 
832         return "global";
833     
834   }
835 }
836
837 function $$export(ex) {
838   var match = ex[/* it */1];
839   return /* Node */Block.__(1, [
840             "export",
841             /* :: */[
842               /* Atom */Block.__(0, [string_with(add_char, match[/* name */0])]),
843               /* :: */[
844                 /* Node */Block.__(1, [
845                     export_kind(match[/* ekind */1]),
846                     /* :: */[
847                       /* Atom */Block.__(0, [Curry._1(I32.to_string_u, match[/* item */2][/* it */1])]),
848                       /* [] */0
849                     ]
850                   ]),
851                 /* [] */0
852               ]
853             ]
854           ]);
855 }
856
857 function var_opt(param) {
858   if (param) {
859     return " " + param[0][/* it */1];
860   }
861   else {
862     return "";
863   }
864 }
865
866 function is_func_import(im) {
867   var match = im[/* it */1][/* ikind */2][/* it */1];
868   if (match.tag) {
869     return /* false */0;
870   }
871   else {
872     return /* true */1;
873   }
874 }
875
876 function is_table_import(im) {
877   var match = im[/* it */1][/* ikind */2][/* it */1];
878   if (match.tag === 1) {
879     return /* true */1;
880   }
881   else {
882     return /* false */0;
883   }
884 }
885
886 function is_memory_import(im) {
887   var match = im[/* it */1][/* ikind */2][/* it */1];
888   if (match.tag === 2) {
889     return /* true */1;
890   }
891   else {
892     return /* false */0;
893   }
894 }
895
896 function is_global_import(im) {
897   var match = im[/* it */1][/* ikind */2][/* it */1];
898   if (match.tag === 3) {
899     return /* true */1;
900   }
901   else {
902     return /* false */0;
903   }
904 }
905
906 function module_with_var_opt(x_opt, m) {
907   var func_imports = List.filter(is_func_import)(m[/* it */1][/* imports */8]);
908   var table_imports = List.filter(is_table_import)(m[/* it */1][/* imports */8]);
909   var memory_imports = List.filter(is_memory_import)(m[/* it */1][/* imports */8]);
910   var global_imports = List.filter(is_global_import)(m[/* it */1][/* imports */8]);
911   var partial_arg = List.length(table_imports);
912   var f = function (param, param$1) {
913     return table(partial_arg, param, param$1);
914   };
915   var partial_arg$1 = List.length(memory_imports);
916   var f$1 = function (param, param$1) {
917     return memory(partial_arg$1, param, param$1);
918   };
919   var partial_arg$2 = List.length(global_imports);
920   var f$2 = function (param, param$1) {
921     var off = partial_arg$2;
922     var i = param;
923     var g = param$1;
924     var match = g[/* it */1];
925     return /* Node */Block.__(1, [
926               "global $" + Curry._1(I32.to_string_u, Curry._1(I32.of_int_u, off + i | 0)),
927               /* :: */[
928                 global_type(match[/* gtype */0]),
929                 List.map(instr, match[/* value */1][/* it */1])
930               ]
931             ]);
932   };
933   var partial_arg$3 = List.length(func_imports);
934   var f$3 = function (param, param$1) {
935     var off = partial_arg$3;
936     var i = param;
937     var f$4 = param$1;
938     return func_with_name(" $" + Curry._1(I32.to_string_u, Curry._1(I32.of_int_u, off + i | 0)), f$4);
939   };
940   var xs = list_of_opt(m[/* it */1][/* start */5]);
941   return /* Node */Block.__(1, [
942             "module" + var_opt(x_opt),
943             Pervasives.$at(List.mapi(typedef, m[/* it */1][/* types */0]), Pervasives.$at(List.mapi($$import, table_imports), Pervasives.$at(List.mapi($$import, memory_imports), Pervasives.$at(List.mapi($$import, global_imports), Pervasives.$at(List.mapi($$import, func_imports), Pervasives.$at(List.mapi(f, m[/* it */1][/* tables */2]), Pervasives.$at(List.mapi(f$1, m[/* it */1][/* memories */3]), Pervasives.$at(List.mapi(f$2, m[/* it */1][/* globals */1]), Pervasives.$at(List.mapi(f$3, m[/* it */1][/* funcs */4]), Pervasives.$at(List.map($$export, m[/* it */1][/* exports */9]), Pervasives.$at(List.map(start, xs), Pervasives.$at(List.map(elems, m[/* it */1][/* elems */6]), List.map(data, m[/* it */1][/* data */7])))))))))))))
944           ]);
945 }
946
947 function module_(param) {
948   return module_with_var_opt(/* None */0, param);
949 }
950
951 function literal(lit) {
952   var match = lit[/* it */1];
953   switch (match.tag | 0) {
954     case 0 : 
955         return /* Node */Block.__(1, [
956                   "i32.const " + Curry._1(I32.to_string_s, match[0]),
957                   /* [] */0
958                 ]);
959     case 1 : 
960         return /* Node */Block.__(1, [
961                   "i64.const " + Curry._1(I64.to_string_s, match[0]),
962                   /* [] */0
963                 ]);
964     case 2 : 
965         return /* Node */Block.__(1, [
966                   "f32.const " + Curry._1(F32.to_string, match[0]),
967                   /* [] */0
968                 ]);
969     case 3 : 
970         return /* Node */Block.__(1, [
971                   "f64.const " + Curry._1(F64.to_string, match[0]),
972                   /* [] */0
973                 ]);
974     
975   }
976 }
977
978 function definition(mode, x_opt, def) {
979   var match = def[/* it */1];
980   var exit = 0;
981   exit = mode !== 564146209 && !(mode >= 983167089 && match.tag) ? 1 : 2;
982   switch (exit) {
983     case 1 : 
984         var match$1 = def[/* it */1];
985         var m;
986         m = match$1.tag ? Decode.decode("", match$1[1]) : match$1[0];
987         return module_with_var_opt(x_opt, m);
988     case 2 : 
989         var match$2 = def[/* it */1];
990         var bs;
991         bs = match$2.tag ? match$2[1] : Encode.encode(match$2[0]);
992         var x_opt$1 = x_opt;
993         var bs$1 = bs;
994         return /* Node */Block.__(1, [
995                   "module" + var_opt(x_opt$1),
996                   break_bytes(bs$1)
997                 ]);
998     
999   }
1000 }
1001
1002 function access(x_opt, name) {
1003   return $$String.concat(" ", /* :: */[
1004               var_opt(x_opt),
1005               /* :: */[
1006                 string_with(add_char, name),
1007                 /* [] */0
1008               ]
1009             ]);
1010 }
1011
1012 function action(act) {
1013   var match = act[/* it */1];
1014   if (match.tag) {
1015     return /* Node */Block.__(1, [
1016               "get" + access(match[0], match[1]),
1017               /* [] */0
1018             ]);
1019   }
1020   else {
1021     return /* Node */Block.__(1, [
1022               "invoke" + access(match[0], match[1]),
1023               List.map(literal, match[2])
1024             ]);
1025   }
1026 }
1027
1028 function script(mode, scr) {
1029   return List.map(function (param) {
1030               var mode$1 = mode;
1031               var cmd = param;
1032               var match = cmd[/* it */1];
1033               switch (match.tag | 0) {
1034                 case 0 : 
1035                     return definition(mode$1, match[0], match[1]);
1036                 case 1 : 
1037                     return /* Node */Block.__(1, [
1038                               "register " + (string_with(add_char, match[0]) + var_opt(match[1])),
1039                               /* [] */0
1040                             ]);
1041                 case 2 : 
1042                     return action(match[0]);
1043                 case 3 : 
1044                     var mode$2 = mode$1;
1045                     var ass = match[0];
1046                     var match$1 = ass[/* it */1];
1047                     switch (match$1.tag | 0) {
1048                       case 0 : 
1049                           return /* Node */Block.__(1, [
1050                                     "assert_malformed",
1051                                     /* :: */[
1052                                       definition(/* Original */983167089, /* None */0, match$1[0]),
1053                                       /* :: */[
1054                                         /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
1055                                         /* [] */0
1056                                       ]
1057                                     ]
1058                                   ]);
1059                       case 1 : 
1060                           return /* Node */Block.__(1, [
1061                                     "assert_invalid",
1062                                     /* :: */[
1063                                       definition(mode$2, /* None */0, match$1[0]),
1064                                       /* :: */[
1065                                         /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
1066                                         /* [] */0
1067                                       ]
1068                                     ]
1069                                   ]);
1070                       case 2 : 
1071                           return /* Node */Block.__(1, [
1072                                     "assert_soft_invalid",
1073                                     /* :: */[
1074                                       definition(mode$2, /* None */0, match$1[0]),
1075                                       /* :: */[
1076                                         /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
1077                                         /* [] */0
1078                                       ]
1079                                     ]
1080                                   ]);
1081                       case 3 : 
1082                           return /* Node */Block.__(1, [
1083                                     "assert_unlinkable",
1084                                     /* :: */[
1085                                       definition(mode$2, /* None */0, match$1[0]),
1086                                       /* :: */[
1087                                         /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
1088                                         /* [] */0
1089                                       ]
1090                                     ]
1091                                   ]);
1092                       case 4 : 
1093                           return /* Node */Block.__(1, [
1094                                     "assert_trap",
1095                                     /* :: */[
1096                                       definition(mode$2, /* None */0, match$1[0]),
1097                                       /* :: */[
1098                                         /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
1099                                         /* [] */0
1100                                       ]
1101                                     ]
1102                                   ]);
1103                       case 5 : 
1104                           return /* Node */Block.__(1, [
1105                                     "assert_return",
1106                                     /* :: */[
1107                                       action(match$1[0]),
1108                                       List.map(literal, match$1[1])
1109                                     ]
1110                                   ]);
1111                       case 6 : 
1112                           return /* Node */Block.__(1, [
1113                                     "assert_return_nan",
1114                                     /* :: */[
1115                                       action(match$1[0]),
1116                                       /* [] */0
1117                                     ]
1118                                   ]);
1119                       case 7 : 
1120                           return /* Node */Block.__(1, [
1121                                     "assert_trap",
1122                                     /* :: */[
1123                                       action(match$1[0]),
1124                                       /* :: */[
1125                                         /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
1126                                         /* [] */0
1127                                       ]
1128                                     ]
1129                                   ]);
1130                       case 8 : 
1131                           return /* Node */Block.__(1, [
1132                                     "assert_exhaustion",
1133                                     /* :: */[
1134                                       action(match$1[0]),
1135                                       /* :: */[
1136                                         /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
1137                                         /* [] */0
1138                                       ]
1139                                     ]
1140                                   ]);
1141                       
1142                     }
1143                 case 4 : 
1144                     throw [
1145                           Caml_builtin_exceptions.assert_failure,
1146                           [
1147                             "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/arrange.ml",
1148                             435,
1149                             14
1150                           ]
1151                         ];
1152                 
1153               }
1154             }, scr);
1155 }
1156
1157 exports.instr   = instr;
1158 exports.func    = func;
1159 exports.module_ = module_;
1160 exports.script  = script;
1161 /* F32 Not a pure module */
1162 //////// end of arrange.js ////////
1163     return exports;
1164   };
1165
1166
1167   _registry['array'] = function() {
1168     let exports = {};
1169 //////// start of array.js ////////
1170 'use strict';
1171
1172 var Curry                   = require("./curry");
1173 var Caml_array              = require("./caml_array");
1174 var Caml_exceptions         = require("./caml_exceptions");
1175 var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
1176
1177 function init(l, f) {
1178   if (l) {
1179     if (l < 0) {
1180       throw [
1181             Caml_builtin_exceptions.invalid_argument,
1182             "Array.init"
1183           ];
1184     }
1185     else {
1186       var res = Caml_array.caml_make_vect(l, Curry._1(f, 0));
1187       for(var i = 1 ,i_finish = l - 1 | 0; i <= i_finish; ++i){
1188         res[i] = Curry._1(f, i);
1189       }
1190       return res;
1191     }
1192   }
1193   else {
1194     return /* array */[];
1195   }
1196 }
1197
1198 function make_matrix(sx, sy, init) {
1199   var res = Caml_array.caml_make_vect(sx, /* array */[]);
1200   for(var x = 0 ,x_finish = sx - 1 | 0; x <= x_finish; ++x){
1201     res[x] = Caml_array.caml_make_vect(sy, init);
1202   }
1203   return res;
1204 }
1205
1206 function copy(a) {
1207   var l = a.length;
1208   if (l) {
1209     return Caml_array.caml_array_sub(a, 0, l);
1210   }
1211   else {
1212     return /* array */[];
1213   }
1214 }
1215
1216 function append(a1, a2) {
1217   var l1 = a1.length;
1218   if (l1) {
1219     if (a2.length) {
1220       return a1.concat(a2);
1221     }
1222     else {
1223       return Caml_array.caml_array_sub(a1, 0, l1);
1224     }
1225   }
1226   else {
1227     return copy(a2);
1228   }
1229 }
1230
1231 function sub(a, ofs, len) {
1232   if (len < 0 || ofs > (a.length - len | 0)) {
1233     throw [
1234           Caml_builtin_exceptions.invalid_argument,
1235           "Array.sub"
1236         ];
1237   }
1238   else {
1239     return Caml_array.caml_array_sub(a, ofs, len);
1240   }
1241 }
1242
1243 function fill(a, ofs, len, v) {
1244   if (ofs < 0 || len < 0 || ofs > (a.length - len | 0)) {
1245     throw [
1246           Caml_builtin_exceptions.invalid_argument,
1247           "Array.fill"
1248         ];
1249   }
1250   else {
1251     for(var i = ofs ,i_finish = (ofs + len | 0) - 1 | 0; i <= i_finish; ++i){
1252       a[i] = v;
1253     }
1254     return /* () */0;
1255   }
1256 }
1257
1258 function blit(a1, ofs1, a2, ofs2, len) {
1259   if (len < 0 || ofs1 < 0 || ofs1 > (a1.length - len | 0) || ofs2 < 0 || ofs2 > (a2.length - len | 0)) {
1260     throw [
1261           Caml_builtin_exceptions.invalid_argument,
1262           "Array.blit"
1263         ];
1264   }
1265   else {
1266     return Caml_array.caml_array_blit(a1, ofs1, a2, ofs2, len);
1267   }
1268 }
1269
1270 function iter(f, a) {
1271   for(var i = 0 ,i_finish = a.length - 1 | 0; i <= i_finish; ++i){
1272     Curry._1(f, a[i]);
1273   }
1274   return /* () */0;
1275 }
1276
1277 function map(f, a) {
1278   var l = a.length;
1279   if (l) {
1280     var r = Caml_array.caml_make_vect(l, Curry._1(f, a[0]));
1281     for(var i = 1 ,i_finish = l - 1 | 0; i <= i_finish; ++i){
1282       r[i] = Curry._1(f, a[i]);
1283     }
1284     return r;
1285   }
1286   else {
1287     return /* array */[];
1288   }
1289 }
1290
1291 function iteri(f, a) {
1292   for(var i = 0 ,i_finish = a.length - 1 | 0; i <= i_finish; ++i){
1293     Curry._2(f, i, a[i]);
1294   }
1295   return /* () */0;
1296 }
1297
1298 function mapi(f, a) {
1299   var l = a.length;
1300   if (l) {
1301     var r = Caml_array.caml_make_vect(l, Curry._2(f, 0, a[0]));
1302     for(var i = 1 ,i_finish = l - 1 | 0; i <= i_finish; ++i){
1303       r[i] = Curry._2(f, i, a[i]);
1304     }
1305     return r;
1306   }
1307   else {
1308     return /* array */[];
1309   }
1310 }
1311
1312 function to_list(a) {
1313   var _i = a.length - 1 | 0;
1314   var _res = /* [] */0;
1315   while(true) {
1316     var res = _res;
1317     var i = _i;
1318     if (i < 0) {
1319       return res;
1320     }
1321     else {
1322       _res = /* :: */[
1323         a[i],
1324         res
1325       ];
1326       _i = i - 1 | 0;
1327       continue ;
1328       
1329     }
1330   };
1331 }
1332
1333 function list_length(_accu, _param) {
1334   while(true) {
1335     var param = _param;
1336     var accu = _accu;
1337     if (param) {
1338       _param = param[1];
1339       _accu = accu + 1 | 0;
1340       continue ;
1341       
1342     }
1343     else {
1344       return accu;
1345     }
1346   };
1347 }
1348
1349 function of_list(l) {
1350   if (l) {
1351     var a = Caml_array.caml_make_vect(list_length(0, l), l[0]);
1352     var _i = 1;
1353     var _param = l[1];
1354     while(true) {
1355       var param = _param;
1356       var i = _i;
1357       if (param) {
1358         a[i] = param[0];
1359         _param = param[1];
1360         _i = i + 1 | 0;
1361         continue ;
1362         
1363       }
1364       else {
1365         return a;
1366       }
1367     };
1368   }
1369   else {
1370     return /* array */[];
1371   }
1372 }
1373
1374 function fold_left(f, x, a) {
1375   var r = x;
1376   for(var i = 0 ,i_finish = a.length - 1 | 0; i <= i_finish; ++i){
1377     r = Curry._2(f, r, a[i]);
1378   }
1379   return r;
1380 }
1381
1382 function fold_right(f, a, x) {
1383   var r = x;
1384   for(var i = a.length - 1 | 0; i >= 0; --i){
1385     r = Curry._2(f, a[i], r);
1386   }
1387   return r;
1388 }
1389
1390 var Bottom = Caml_exceptions.create("Array.Bottom");
1391
1392 function sort(cmp, a) {
1393   var maxson = function (l, i) {
1394     var i31 = ((i + i | 0) + i | 0) + 1 | 0;
1395     var x = i31;
1396     if ((i31 + 2 | 0) < l) {
1397       if (Curry._2(cmp, a[i31], a[i31 + 1 | 0]) < 0) {
1398         x = i31 + 1 | 0;
1399       }
1400       if (Curry._2(cmp, a[x], a[i31 + 2 | 0]) < 0) {
1401         x = i31 + 2 | 0;
1402       }
1403       return x;
1404     }
1405     else if ((i31 + 1 | 0) < l && Curry._2(cmp, a[i31], a[i31 + 1 | 0]) < 0) {
1406       return i31 + 1 | 0;
1407     }
1408     else if (i31 < l) {
1409       return i31;
1410     }
1411     else {
1412       throw [
1413             Bottom,
1414             i
1415           ];
1416     }
1417   };
1418   var trickle = function (l, i, e) {
1419     try {
1420       var l$1 = l;
1421       var _i = i;
1422       var e$1 = e;
1423       while(true) {
1424         var i$1 = _i;
1425         var j = maxson(l$1, i$1);
1426         if (Curry._2(cmp, a[j], e$1) > 0) {
1427           a[i$1] = a[j];
1428           _i = j;
1429           continue ;
1430           
1431         }
1432         else {
1433           a[i$1] = e$1;
1434           return /* () */0;
1435         }
1436       };
1437     }
1438     catch (exn){
1439       if (exn[0] === Bottom) {
1440         a[exn[1]] = e;
1441         return /* () */0;
1442       }
1443       else {
1444         throw exn;
1445       }
1446     }
1447   };
1448   var bubble = function (l, i) {
1449     try {
1450       var l$1 = l;
1451       var _i = i;
1452       while(true) {
1453         var i$1 = _i;
1454         var j = maxson(l$1, i$1);
1455         a[i$1] = a[j];
1456         _i = j;
1457         continue ;
1458         
1459       };
1460     }
1461     catch (exn){
1462       if (exn[0] === Bottom) {
1463         return exn[1];
1464       }
1465       else {
1466         throw exn;
1467       }
1468     }
1469   };
1470   var trickleup = function (_i, e) {
1471     while(true) {
1472       var i = _i;
1473       var father = (i - 1 | 0) / 3 | 0;
1474       if (i === father) {
1475         throw [
1476               Caml_builtin_exceptions.assert_failure,
1477               [
1478                 "array.ml",
1479                 168,
1480                 4
1481               ]
1482             ];
1483       }
1484       if (Curry._2(cmp, a[father], e) < 0) {
1485         a[i] = a[father];
1486         if (father > 0) {
1487           _i = father;
1488           continue ;
1489           
1490         }
1491         else {
1492           a[0] = e;
1493           return /* () */0;
1494         }
1495       }
1496       else {
1497         a[i] = e;
1498         return /* () */0;
1499       }
1500     };
1501   };
1502   var l = a.length;
1503   for(var i = ((l + 1 | 0) / 3 | 0) - 1 | 0; i >= 0; --i){
1504     trickle(l, i, a[i]);
1505   }
1506   for(var i$1 = l - 1 | 0; i$1 >= 2; --i$1){
1507     var e = a[i$1];
1508     a[i$1] = a[0];
1509     trickleup(bubble(i$1, 0), e);
1510   }
1511   if (l > 1) {
1512     var e$1 = a[1];
1513     a[1] = a[0];
1514     a[0] = e$1;
1515     return /* () */0;
1516   }
1517   else {
1518     return 0;
1519   }
1520 }
1521
1522 function stable_sort(cmp, a) {
1523   var merge = function (src1ofs, src1len, src2, src2ofs, src2len, dst, dstofs) {
1524     var src1r = src1ofs + src1len | 0;
1525     var src2r = src2ofs + src2len | 0;
1526     var _i1 = src1ofs;
1527     var _s1 = a[src1ofs];
1528     var _i2 = src2ofs;
1529     var _s2 = src2[src2ofs];
1530     var _d = dstofs;
1531     while(true) {
1532       var d = _d;
1533       var s2 = _s2;
1534       var i2 = _i2;
1535       var s1 = _s1;
1536       var i1 = _i1;
1537       if (Curry._2(cmp, s1, s2) <= 0) {
1538         dst[d] = s1;
1539         var i1$1 = i1 + 1 | 0;
1540         if (i1$1 < src1r) {
1541           _d = d + 1 | 0;
1542           _s1 = a[i1$1];
1543           _i1 = i1$1;
1544           continue ;
1545           
1546         }
1547         else {
1548           return blit(src2, i2, dst, d + 1 | 0, src2r - i2 | 0);
1549         }
1550       }
1551       else {
1552         dst[d] = s2;
1553         var i2$1 = i2 + 1 | 0;
1554         if (i2$1 < src2r) {
1555           _d = d + 1 | 0;
1556           _s2 = src2[i2$1];
1557           _i2 = i2$1;
1558           continue ;
1559           
1560         }
1561         else {
1562           return blit(a, i1, dst, d + 1 | 0, src1r - i1 | 0);
1563         }
1564       }
1565     };
1566   };
1567   var isortto = function (srcofs, dst, dstofs, len) {
1568     for(var i = 0 ,i_finish = len - 1 | 0; i <= i_finish; ++i){
1569       var e = a[srcofs + i | 0];
1570       var j = (dstofs + i | 0) - 1 | 0;
1571       while(j >= dstofs && Curry._2(cmp, dst[j], e) > 0) {
1572         dst[j + 1 | 0] = dst[j];
1573         j = j - 1 | 0;
1574       };
1575       dst[j + 1 | 0] = e;
1576     }
1577     return /* () */0;
1578   };
1579   var sortto = function (srcofs, dst, dstofs, len) {
1580     if (len <= 5) {
1581       return isortto(srcofs, dst, dstofs, len);
1582     }
1583     else {
1584       var l1 = len / 2 | 0;
1585       var l2 = len - l1 | 0;
1586       sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
1587       sortto(srcofs, a, srcofs + l2 | 0, l1);
1588       return merge(srcofs + l2 | 0, l1, dst, dstofs + l1 | 0, l2, dst, dstofs);
1589     }
1590   };
1591   var l = a.length;
1592   if (l <= 5) {
1593     return isortto(0, a, 0, l);
1594   }
1595   else {
1596     var l1 = l / 2 | 0;
1597     var l2 = l - l1 | 0;
1598     var t = Caml_array.caml_make_vect(l2, a[0]);
1599     sortto(l1, t, 0, l2);
1600     sortto(0, a, l2, l1);
1601     return merge(l2, l1, t, 0, l2, a, 0);
1602   }
1603 }
1604
1605 var create_matrix = make_matrix;
1606
1607 var concat = Caml_array.caml_array_concat;
1608
1609 var fast_sort = stable_sort;
1610
1611 exports.init          = init;
1612 exports.make_matrix   = make_matrix;
1613 exports.create_matrix = create_matrix;
1614 exports.append        = append;
1615 exports.concat        = concat;
1616 exports.sub           = sub;
1617 exports.copy          = copy;
1618 exports.fill          = fill;
1619 exports.blit          = blit;
1620 exports.to_list       = to_list;
1621 exports.of_list       = of_list;
1622 exports.iter          = iter;
1623 exports.map           = map;
1624 exports.iteri         = iteri;
1625 exports.mapi          = mapi;
1626 exports.fold_left     = fold_left;
1627 exports.fold_right    = fold_right;
1628 exports.sort          = sort;
1629 exports.stable_sort   = stable_sort;
1630 exports.fast_sort     = fast_sort;
1631 /* No side effect */
1632 //////// end of array.js ////////
1633     return exports;
1634   };
1635
1636
1637   _registry['ast'] = function() {
1638     let exports = {};
1639 //////// start of ast.js ////////
1640 // Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
1641 'use strict';
1642
1643 var Lib      = require("./lib");
1644 var Block    = require("bs-platform/lib/js/block");
1645 var Curry    = require("bs-platform/lib/js/curry");
1646 var Caml_obj = require("bs-platform/lib/js/caml_obj");
1647
1648 var IntOp = /* module */[];
1649
1650 var FloatOp = /* module */[];
1651
1652 function export_kind_of_import_kind(param) {
1653   switch (param.tag | 0) {
1654     case 0 : 
1655         return /* FuncExport */0;
1656     case 1 : 
1657         return /* TableExport */1;
1658     case 2 : 
1659         return /* MemoryExport */2;
1660     case 3 : 
1661         return /* GlobalExport */3;
1662     
1663   }
1664 }
1665
1666 function import_type(m, im) {
1667   var match = im[/* it */1];
1668   var match$1 = match[/* ikind */2][/* it */1];
1669   switch (match$1.tag | 0) {
1670     case 0 : 
1671         return /* ExternalFuncType */Block.__(0, [Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* types */0], match$1[0][/* it */1])]);
1672     case 1 : 
1673         return /* ExternalTableType */Block.__(1, [match$1[0]]);
1674     case 2 : 
1675         return /* ExternalMemoryType */Block.__(2, [match$1[0]]);
1676     case 3 : 
1677         return /* ExternalGlobalType */Block.__(3, [match$1[0]]);
1678     
1679   }
1680 }
1681
1682 function export_type(m, ex) {
1683   var match = ex[/* it */1];
1684   var ekind = match[/* ekind */1];
1685   var _i = match[/* item */2][/* it */1];
1686   var _param = m[/* it */1][/* imports */8];
1687   while(true) {
1688     var param = _param;
1689     var i = _i;
1690     if (param) {
1691       var ims = param[1];
1692       var im = param[0];
1693       if (Caml_obj.caml_equal(export_kind_of_import_kind(im[/* it */1][/* ikind */2][/* it */1]), ekind[/* it */1])) {
1694         if (i) {
1695           _param = ims;
1696           _i = i - 1 | 0;
1697           continue ;
1698           
1699         }
1700         else {
1701           return import_type(m, im);
1702         }
1703       }
1704       else {
1705         _param = ims;
1706         continue ;
1707         
1708       }
1709     }
1710     else {
1711       var match$1 = ekind[/* it */1];
1712       switch (match$1) {
1713         case 0 : 
1714             return /* ExternalFuncType */Block.__(0, [Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* types */0], Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* funcs */4], i)[/* it */1][/* ftype */0][/* it */1])]);
1715         case 1 : 
1716             return /* ExternalTableType */Block.__(1, [Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* tables */2], i)[/* it */1][/* ttype */0]]);
1717         case 2 : 
1718             return /* ExternalMemoryType */Block.__(2, [Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* memories */3], i)[/* it */1][/* mtype */0]]);
1719         case 3 : 
1720             return /* ExternalGlobalType */Block.__(3, [Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* globals */1], i)[/* it */1][/* gtype */0]]);
1721         
1722       }
1723     }
1724   };
1725 }
1726
1727 var I32Op = 0;
1728
1729 var I64Op = 0;
1730
1731 var F32Op = 0;
1732
1733 var F64Op = 0;
1734
1735 var empty_module = /* record */[
1736   /* types : [] */0,
1737   /* globals : [] */0,
1738   /* tables : [] */0,
1739   /* memories : [] */0,
1740   /* funcs : [] */0,
1741   /* start : None */0,
1742   /* elems : [] */0,
1743   /* data : [] */0,
1744   /* imports : [] */0,
1745   /* exports : [] */0
1746 ];
1747
1748 exports.IntOp                      = IntOp;
1749 exports.FloatOp                    = FloatOp;
1750 exports.I32Op                      = I32Op;
1751 exports.I64Op                      = I64Op;
1752 exports.F32Op                      = F32Op;
1753 exports.F64Op                      = F64Op;
1754 exports.empty_module               = empty_module;
1755 exports.export_kind_of_import_kind = export_kind_of_import_kind;
1756 exports.import_type                = import_type;
1757 exports.export_type                = export_type;
1758 /* Lib Not a pure module */
1759 //////// end of ast.js ////////
1760     return exports;
1761   };
1762
1763
1764   _registry['bigarray'] = function() {
1765     let exports = {};
1766 //////// start of bigarray.js ////////
1767 'use strict';
1768
1769 var Caml_array              = require("./caml_array");
1770 var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
1771
1772 function dims() {
1773   var n = function () {
1774       throw "caml_ba_num_dims not implemented by bucklescript yet\n";
1775     }();
1776   var d = Caml_array.caml_make_vect(n, 0);
1777   for(var i = 0 ,i_finish = n - 1 | 0; i <= i_finish; ++i){
1778     d[i] = function () {
1779         throw "caml_ba_dim not implemented by bucklescript yet\n";
1780       }();
1781   }
1782   return d;
1783 }
1784
1785 function map_file(_, $staropt$star, _$1, _$2, _$3, _$4) {
1786   $staropt$star ? $staropt$star[0] : /* int64 */[
1787       /* hi */0,
1788       /* lo */0
1789     ];
1790   return function () {
1791             throw "caml_ba_map_file_bytecode not implemented by bucklescript yet\n";
1792           }();
1793 }
1794
1795 var Genarray = /* module */[
1796   /* dims */dims,
1797   /* map_file */map_file
1798 ];
1799
1800 function create(_, _$1, _$2) {
1801   return function () {
1802             throw "caml_ba_create not implemented by bucklescript yet\n";
1803           }();
1804 }
1805
1806 function of_array(kind, layout, data) {
1807   var ba = create(kind, layout, data.length);
1808   layout !== 0 ? 1 : 0;
1809   for(var i = 0 ,i_finish = data.length - 1 | 0; i <= i_finish; ++i){
1810     (function () {
1811           throw "caml_ba_set_1 not implemented by bucklescript yet\n";
1812         }());
1813   }
1814   return ba;
1815 }
1816
1817 function map_file$1(fd, pos, kind, layout, shared, dim) {
1818   return map_file(fd, pos, kind, layout, shared, /* int array */[dim]);
1819 }
1820
1821 var Array1 = /* module */[
1822   /* create */create,
1823   /* of_array */of_array,
1824   /* map_file */map_file$1
1825 ];
1826
1827 function create$1(_, _$1, _$2, _$3) {
1828   return function () {
1829             throw "caml_ba_create not implemented by bucklescript yet\n";
1830           }();
1831 }
1832
1833 function slice_left(_, _$1) {
1834   return function () {
1835             throw "caml_ba_slice not implemented by bucklescript yet\n";
1836           }();
1837 }
1838
1839 function slice_right(_, _$1) {
1840   return function () {
1841             throw "caml_ba_slice not implemented by bucklescript yet\n";
1842           }();
1843 }
1844
1845 function of_array$1(kind, layout, data) {
1846   var dim1 = data.length;
1847   var dim2 = dim1 ? data[0].length : 0;
1848   var ba = create$1(kind, layout, dim1, dim2);
1849   layout !== 0 ? 1 : 0;
1850   for(var i = 0 ,i_finish = dim1 - 1 | 0; i <= i_finish; ++i){
1851     var row = data[i];
1852     if (row.length !== dim2) {
1853       throw [
1854             Caml_builtin_exceptions.invalid_argument,
1855             "Bigarray.Array2.of_array: non-rectangular data"
1856           ];
1857     }
1858     for(var j = 0 ,j_finish = dim2 - 1 | 0; j <= j_finish; ++j){
1859       (function () {
1860             throw "caml_ba_set_2 not implemented by bucklescript yet\n";
1861           }());
1862     }
1863   }
1864   return ba;
1865 }
1866
1867 function map_file$2(fd, pos, kind, layout, shared, dim1, dim2) {
1868   return map_file(fd, pos, kind, layout, shared, /* int array */[
1869               dim1,
1870               dim2
1871             ]);
1872 }
1873
1874 var Array2 = /* module */[
1875   /* create */create$1,
1876   /* slice_left */slice_left,
1877   /* slice_right */slice_right,
1878   /* of_array */of_array$1,
1879   /* map_file */map_file$2
1880 ];
1881
1882 function create$2(_, _$1, _$2, _$3, _$4) {
1883   return function () {
1884             throw "caml_ba_create not implemented by bucklescript yet\n";
1885           }();
1886 }
1887
1888 function slice_left_1(_, _$1, _$2) {
1889   return function () {
1890             throw "caml_ba_slice not implemented by bucklescript yet\n";
1891           }();
1892 }
1893
1894 function slice_right_1(_, _$1, _$2) {
1895   return function () {
1896             throw "caml_ba_slice not implemented by bucklescript yet\n";
1897           }();
1898 }
1899
1900 function slice_left_2(_, _$1) {
1901   return function () {
1902             throw "caml_ba_slice not implemented by bucklescript yet\n";
1903           }();
1904 }
1905
1906 function slice_right_2(_, _$1) {
1907   return function () {
1908             throw "caml_ba_slice not implemented by bucklescript yet\n";
1909           }();
1910 }
1911
1912 function of_array$2(kind, layout, data) {
1913   var dim1 = data.length;
1914   var dim2 = dim1 ? data[0].length : 0;
1915   var dim3 = dim2 ? data[0][0].length : 0;
1916   var ba = create$2(kind, layout, dim1, dim2, dim3);
1917   layout !== 0 ? 1 : 0;
1918   for(var i = 0 ,i_finish = dim1 - 1 | 0; i <= i_finish; ++i){
1919     var row = data[i];
1920     if (row.length !== dim2) {
1921       throw [
1922             Caml_builtin_exceptions.invalid_argument,
1923             "Bigarray.Array3.of_array: non-cubic data"
1924           ];
1925     }
1926     for(var j = 0 ,j_finish = dim2 - 1 | 0; j <= j_finish; ++j){
1927       var col = row[j];
1928       if (col.length !== dim3) {
1929         throw [
1930               Caml_builtin_exceptions.invalid_argument,
1931               "Bigarray.Array3.of_array: non-cubic data"
1932             ];
1933       }
1934       for(var k = 0 ,k_finish = dim3 - 1 | 0; k <= k_finish; ++k){
1935         (function () {
1936               throw "caml_ba_set_3 not implemented by bucklescript yet\n";
1937             }());
1938       }
1939     }
1940   }
1941   return ba;
1942 }
1943
1944 function map_file$3(fd, pos, kind, layout, shared, dim1, dim2, dim3) {
1945   return map_file(fd, pos, kind, layout, shared, /* int array */[
1946               dim1,
1947               dim2,
1948               dim3
1949             ]);
1950 }
1951
1952 var Array3 = /* module */[
1953   /* create */create$2,
1954   /* slice_left_1 */slice_left_1,
1955   /* slice_right_1 */slice_right_1,
1956   /* slice_left_2 */slice_left_2,
1957   /* slice_right_2 */slice_right_2,
1958   /* of_array */of_array$2,
1959   /* map_file */map_file$3
1960 ];
1961
1962 function array1_of_genarray(a) {
1963   if (function () {
1964         throw "caml_ba_num_dims not implemented by bucklescript yet\n";
1965       }() === 1) {
1966     return a;
1967   }
1968   else {
1969     throw [
1970           Caml_builtin_exceptions.invalid_argument,
1971           "Bigarray.array1_of_genarray"
1972         ];
1973   }
1974 }
1975
1976 function array2_of_genarray(a) {
1977   if (function () {
1978         throw "caml_ba_num_dims not implemented by bucklescript yet\n";
1979       }() === 2) {
1980     return a;
1981   }
1982   else {
1983     throw [
1984           Caml_builtin_exceptions.invalid_argument,
1985           "Bigarray.array2_of_genarray"
1986         ];
1987   }
1988 }
1989
1990 function array3_of_genarray(a) {
1991   if (function () {
1992         throw "caml_ba_num_dims not implemented by bucklescript yet\n";
1993       }() === 3) {
1994     return a;
1995   }
1996   else {
1997     throw [
1998           Caml_builtin_exceptions.invalid_argument,
1999           "Bigarray.array3_of_genarray"
2000         ];
2001   }
2002 }
2003
2004 function reshape_1(_, _$1) {
2005   return function () {
2006             throw "caml_ba_reshape not implemented by bucklescript yet\n";
2007           }();
2008 }
2009
2010 function reshape_2(_, _$1, _$2) {
2011   return function () {
2012             throw "caml_ba_reshape not implemented by bucklescript yet\n";
2013           }();
2014 }
2015
2016 function reshape_3(_, _$1, _$2, _$3) {
2017   return function () {
2018             throw "caml_ba_reshape not implemented by bucklescript yet\n";
2019           }();
2020 }
2021
2022 var float32 = /* Float32 */0;
2023
2024 var float64 = /* Float64 */1;
2025
2026 var complex32 = /* Complex32 */10;
2027
2028 var complex64 = /* Complex64 */11;
2029
2030 var int8_signed = /* Int8_signed */2;
2031
2032 var int8_unsigned = /* Int8_unsigned */3;
2033
2034 var int16_signed = /* Int16_signed */4;
2035
2036 var int16_unsigned = /* Int16_unsigned */5;
2037
2038 var $$int = /* Int */8;
2039
2040 var int32 = /* Int32 */6;
2041
2042 var int64 = /* Int64 */7;
2043
2044 var nativeint = /* Nativeint */9;
2045
2046 var $$char = /* Char */12;
2047
2048 var c_layout = /* C_layout */0;
2049
2050 var fortran_layout = /* Fortran_layout */1;
2051
2052 function reshape(_, _$1) {
2053   return function () {
2054             throw "caml_ba_reshape not implemented by bucklescript yet\n";
2055           }();
2056 }
2057
2058 exports.float32            = float32;
2059 exports.float64            = float64;
2060 exports.complex32          = complex32;
2061 exports.complex64          = complex64;
2062 exports.int8_signed        = int8_signed;
2063 exports.int8_unsigned      = int8_unsigned;
2064 exports.int16_signed       = int16_signed;
2065 exports.int16_unsigned     = int16_unsigned;
2066 exports.$$int              = $$int;
2067 exports.int32              = int32;
2068 exports.int64              = int64;
2069 exports.nativeint          = nativeint;
2070 exports.$$char             = $$char;
2071 exports.c_layout           = c_layout;
2072 exports.fortran_layout     = fortran_layout;
2073 exports.Genarray           = Genarray;
2074 exports.Array1             = Array1;
2075 exports.Array2             = Array2;
2076 exports.Array3             = Array3;
2077 exports.array1_of_genarray = array1_of_genarray;
2078 exports.array2_of_genarray = array2_of_genarray;
2079 exports.array3_of_genarray = array3_of_genarray;
2080 exports.reshape            = reshape;
2081 exports.reshape_1          = reshape_1;
2082 exports.reshape_2          = reshape_2;
2083 exports.reshape_3          = reshape_3;
2084 /*  Not a pure module */
2085 //////// end of bigarray.js ////////
2086     return exports;
2087   };
2088
2089
2090   _registry['block'] = function() {
2091     let exports = {};
2092 //////// start of block.js ////////
2093 'use strict';
2094
2095
2096 function __(tag, block) {
2097   block.tag = tag;
2098   return block;
2099 }
2100
2101 exports.__ = __;
2102 /* No side effect */
2103 //////// end of block.js ////////
2104     return exports;
2105   };
2106
2107
2108   _registry['buffer'] = function() {
2109     let exports = {};
2110 //////// start of buffer.js ////////
2111 'use strict';
2112
2113 var Sys                     = require("./sys");
2114 var Bytes                   = require("./bytes");
2115 var Curry                   = require("./curry");
2116 var $$String                = require("./string");
2117 var Pervasives              = require("./pervasives");
2118 var Caml_string             = require("./caml_string");
2119 var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
2120
2121 function create(n) {
2122   var n$1 = n < 1 ? 1 : n;
2123   var n$2 = n$1 > Sys.max_string_length ? Sys.max_string_length : n$1;
2124   var s = Caml_string.caml_create_string(n$2);
2125   return /* record */[
2126           /* buffer */s,
2127           /* position */0,
2128           /* length */n$2,
2129           /* initial_buffer */s
2130         ];
2131 }
2132
2133 function contents(b) {
2134   return Bytes.sub_string(b[/* buffer */0], 0, b[/* position */1]);
2135 }
2136
2137 function to_bytes(b) {
2138   return Bytes.sub(b[/* buffer */0], 0, b[/* position */1]);
2139 }
2140
2141 function sub(b, ofs, len) {
2142   if (ofs < 0 || len < 0 || ofs > (b[/* position */1] - len | 0)) {
2143     throw [
2144           Caml_builtin_exceptions.invalid_argument,
2145           "Buffer.sub"
2146         ];
2147   }
2148   else {
2149     return Bytes.sub_string(b[/* buffer */0], ofs, len);
2150   }
2151 }
2152
2153 function blit(src, srcoff, dst, dstoff, len) {
2154   if (len < 0 || srcoff < 0 || srcoff > (src[/* position */1] - len | 0) || dstoff < 0 || dstoff > (dst.length - len | 0)) {
2155     throw [
2156           Caml_builtin_exceptions.invalid_argument,
2157           "Buffer.blit"
2158         ];
2159   }
2160   else {
2161     return Bytes.blit(src[/* buffer */0], srcoff, dst, dstoff, len);
2162   }
2163 }
2164
2165 function nth(b, ofs) {
2166   if (ofs < 0 || ofs >= b[/* position */1]) {
2167     throw [
2168           Caml_builtin_exceptions.invalid_argument,
2169           "Buffer.nth"
2170         ];
2171   }
2172   else {
2173     return b[/* buffer */0][ofs];
2174   }
2175 }
2176
2177 function length(b) {
2178   return b[/* position */1];
2179 }
2180
2181 function clear(b) {
2182   b[/* position */1] = 0;
2183   return /* () */0;
2184 }
2185
2186 function reset(b) {
2187   b[/* position */1] = 0;
2188   b[/* buffer */0] = b[/* initial_buffer */3];
2189   b[/* length */2] = b[/* buffer */0].length;
2190   return /* () */0;
2191 }
2192
2193 function resize(b, more) {
2194   var len = b[/* length */2];
2195   var new_len = len;
2196   while((b[/* position */1] + more | 0) > new_len) {
2197     new_len = (new_len << 1);
2198   };
2199   if (new_len > Sys.max_string_length) {
2200     if ((b[/* position */1] + more | 0) <= Sys.max_string_length) {
2201       new_len = Sys.max_string_length;
2202     }
2203     else {
2204       throw [
2205             Caml_builtin_exceptions.failure,
2206             "Buffer.add: cannot grow buffer"
2207           ];
2208     }
2209   }
2210   var new_buffer = Caml_string.caml_create_string(new_len);
2211   Bytes.blit(b[/* buffer */0], 0, new_buffer, 0, b[/* position */1]);
2212   b[/* buffer */0] = new_buffer;
2213   b[/* length */2] = new_len;
2214   return /* () */0;
2215 }
2216
2217 function add_char(b, c) {
2218   var pos = b[/* position */1];
2219   if (pos >= b[/* length */2]) {
2220     resize(b, 1);
2221   }
2222   b[/* buffer */0][pos] = c;
2223   b[/* position */1] = pos + 1 | 0;
2224   return /* () */0;
2225 }
2226
2227 function add_substring(b, s, offset, len) {
2228   if (offset < 0 || len < 0 || (offset + len | 0) > s.length) {
2229     throw [
2230           Caml_builtin_exceptions.invalid_argument,
2231           "Buffer.add_substring/add_subbytes"
2232         ];
2233   }
2234   var new_position = b[/* position */1] + len | 0;
2235   if (new_position > b[/* length */2]) {
2236     resize(b, len);
2237   }
2238   Bytes.blit_string(s, offset, b[/* buffer */0], b[/* position */1], len);
2239   b[/* position */1] = new_position;
2240   return /* () */0;
2241 }
2242
2243 function add_subbytes(b, s, offset, len) {
2244   return add_substring(b, Caml_string.bytes_to_string(s), offset, len);
2245 }
2246
2247 function add_string(b, s) {
2248   var len = s.length;
2249   var new_position = b[/* position */1] + len | 0;
2250   if (new_position > b[/* length */2]) {
2251     resize(b, len);
2252   }
2253   Bytes.blit_string(s, 0, b[/* buffer */0], b[/* position */1], len);
2254   b[/* position */1] = new_position;
2255   return /* () */0;
2256 }
2257
2258 function add_bytes(b, s) {
2259   return add_string(b, Caml_string.bytes_to_string(s));
2260 }
2261
2262 function add_buffer(b, bs) {
2263   return add_subbytes(b, bs[/* buffer */0], 0, bs[/* position */1]);
2264 }
2265
2266 function add_channel(b, ic, len) {
2267   if (len < 0 || len > Sys.max_string_length) {
2268     throw [
2269           Caml_builtin_exceptions.invalid_argument,
2270           "Buffer.add_channel"
2271         ];
2272   }
2273   if ((b[/* position */1] + len | 0) > b[/* length */2]) {
2274     resize(b, len);
2275   }
2276   Pervasives.really_input(ic, b[/* buffer */0], b[/* position */1], len);
2277   b[/* position */1] = b[/* position */1] + len | 0;
2278   return /* () */0;
2279 }
2280
2281 function output_buffer(oc, b) {
2282   return Pervasives.output(oc, b[/* buffer */0], 0, b[/* position */1]);
2283 }
2284
2285 function closing(param) {
2286   if (param !== 40) {
2287     if (param !== 123) {
2288       throw [
2289             Caml_builtin_exceptions.assert_failure,
2290             [
2291               "buffer.ml",
2292               115,
2293               9
2294             ]
2295           ];
2296     }
2297     else {
2298       return /* "}" */125;
2299     }
2300   }
2301   else {
2302     return /* ")" */41;
2303   }
2304 }
2305
2306 function advance_to_closing(opening, closing, k, s, start) {
2307   var _k = k;
2308   var _i = start;
2309   var lim = s.length;
2310   while(true) {
2311     var i = _i;
2312     var k$1 = _k;
2313     if (i >= lim) {
2314       throw Caml_builtin_exceptions.not_found;
2315     }
2316     else if (Caml_string.get(s, i) === opening) {
2317       _i = i + 1 | 0;
2318       _k = k$1 + 1 | 0;
2319       continue ;
2320       
2321     }
2322     else if (Caml_string.get(s, i) === closing) {
2323       if (k$1) {
2324         _i = i + 1 | 0;
2325         _k = k$1 - 1 | 0;
2326         continue ;
2327         
2328       }
2329       else {
2330         return i;
2331       }
2332     }
2333     else {
2334       _i = i + 1 | 0;
2335       continue ;
2336       
2337     }
2338   };
2339 }
2340
2341 function advance_to_non_alpha(s, start) {
2342   var _i = start;
2343   var lim = s.length;
2344   while(true) {
2345     var i = _i;
2346     if (i >= lim) {
2347       return lim;
2348     }
2349     else {
2350       var match = Caml_string.get(s, i);
2351       var exit = 0;
2352       if (match >= 91) {
2353         if (match >= 97) {
2354           if (match >= 123) {
2355             return i;
2356           }
2357           else {
2358             exit = 1;
2359           }
2360         }
2361         else if (match !== 95) {
2362           return i;
2363         }
2364         else {
2365           exit = 1;
2366         }
2367       }
2368       else if (match >= 58) {
2369         if (match >= 65) {
2370           exit = 1;
2371         }
2372         else {
2373           return i;
2374         }
2375       }
2376       else if (match >= 48) {
2377         exit = 1;
2378       }
2379       else {
2380         return i;
2381       }
2382       if (exit === 1) {
2383         _i = i + 1 | 0;
2384         continue ;
2385         
2386       }
2387       
2388     }
2389   };
2390 }
2391
2392 function find_ident(s, start, lim) {
2393   if (start >= lim) {
2394     throw Caml_builtin_exceptions.not_found;
2395   }
2396   else {
2397     var c = Caml_string.get(s, start);
2398     var exit = 0;
2399     if (c !== 40) {
2400       if (c !== 123) {
2401         var stop = advance_to_non_alpha(s, start + 1 | 0);
2402         return /* tuple */[
2403                 $$String.sub(s, start, stop - start | 0),
2404                 stop
2405               ];
2406       }
2407       else {
2408         exit = 1;
2409       }
2410     }
2411     else {
2412       exit = 1;
2413     }
2414     if (exit === 1) {
2415       var new_start = start + 1 | 0;
2416       var stop$1 = advance_to_closing(c, closing(c), 0, s, new_start);
2417       return /* tuple */[
2418               $$String.sub(s, new_start, (stop$1 - start | 0) - 1 | 0),
2419               stop$1 + 1 | 0
2420             ];
2421     }
2422     
2423   }
2424 }
2425
2426 function add_substitute(b, f, s) {
2427   var lim = s.length;
2428   var _previous = /* " " */32;
2429   var _i = 0;
2430   while(true) {
2431     var i = _i;
2432     var previous = _previous;
2433     if (i < lim) {
2434       var current = Caml_string.get(s, i);
2435       if (current !== 36) {
2436         if (previous === /* "\\" */92) {
2437           add_char(b, /* "\\" */92);
2438           add_char(b, current);
2439           _i = i + 1 | 0;
2440           _previous = /* " " */32;
2441           continue ;
2442           
2443         }
2444         else if (current !== 92) {
2445           add_char(b, current);
2446           _i = i + 1 | 0;
2447           _previous = current;
2448           continue ;
2449           
2450         }
2451         else {
2452           _i = i + 1 | 0;
2453           _previous = current;
2454           continue ;
2455           
2456         }
2457       }
2458       else if (previous === /* "\\" */92) {
2459         add_char(b, current);
2460         _i = i + 1 | 0;
2461         _previous = /* " " */32;
2462         continue ;
2463         
2464       }
2465       else {
2466         var j = i + 1 | 0;
2467         var match = find_ident(s, j, lim);
2468         add_string(b, Curry._1(f, match[0]));
2469         _i = match[1];
2470         _previous = /* " " */32;
2471         continue ;
2472         
2473       }
2474     }
2475     else if (previous === /* "\\" */92) {
2476       return add_char(b, previous);
2477     }
2478     else {
2479       return 0;
2480     }
2481   };
2482 }
2483
2484 exports.create         = create;
2485 exports.contents       = contents;
2486 exports.to_bytes       = to_bytes;
2487 exports.sub            = sub;
2488 exports.blit           = blit;
2489 exports.nth            = nth;
2490 exports.length         = length;
2491 exports.clear          = clear;
2492 exports.reset          = reset;
2493 exports.add_char       = add_char;
2494 exports.add_string     = add_string;
2495 exports.add_bytes      = add_bytes;
2496 exports.add_substring  = add_substring;
2497 exports.add_subbytes   = add_subbytes;
2498 exports.add_substitute = add_substitute;
2499 exports.add_buffer     = add_buffer;
2500 exports.add_channel    = add_channel;
2501 exports.output_buffer  = output_buffer;
2502 /* No side effect */
2503 //////// end of buffer.js ////////
2504     return exports;
2505   };
2506
2507
2508   _registry['bytes'] = function() {
2509     let exports = {};
2510 //////// start of bytes.js ////////
2511 'use strict';
2512
2513 var Char                    = require("./char");
2514 var List                    = require("./list");
2515 var Curry                   = require("./curry");
2516 var Caml_obj                = require("./caml_obj");
2517 var Caml_int32              = require("./caml_int32");
2518 var Pervasives              = require("./pervasives");
2519 var Caml_string             = require("./caml_string");
2520 var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
2521
2522 function make(n, c) {
2523   var s = Caml_string.caml_create_string(n);
2524   Caml_string.caml_fill_string(s, 0, n, c);
2525   return s;
2526 }
2527
2528 function init(n, f) {
2529   var s = Caml_string.caml_create_string(n);
2530   for(var i = 0 ,i_finish = n - 1 | 0; i <= i_finish; ++i){
2531     s[i] = Curry._1(f, i);
2532   }
2533   return s;
2534 }
2535
2536 var empty = [];
2537
2538 function copy(s) {
2539   var len = s.length;
2540   var r = Caml_string.caml_create_string(len);
2541   Caml_string.caml_blit_bytes(s, 0, r, 0, len);
2542   return r;
2543 }
2544
2545 function to_string(b) {
2546   return Caml_string.bytes_to_string(copy(b));
2547 }
2548
2549 function of_string(s) {
2550   return copy(Caml_string.bytes_of_string(s));
2551 }
2552
2553 function sub(s, ofs, len) {
2554   if (ofs < 0 || len < 0 || ofs > (s.length - len | 0)) {
2555     throw [
2556           Caml_builtin_exceptions.invalid_argument,
2557           "String.sub / Bytes.sub"
2558         ];
2559   }
2560   else {
2561     var r = Caml_string.caml_create_string(len);
2562     Caml_string.caml_blit_bytes(s, ofs, r, 0, len);
2563     return r;
2564   }
2565 }
2566
2567 function sub_string(b, ofs, len) {
2568   return Caml_string.bytes_to_string(sub(b, ofs, len));
2569 }
2570
2571 function extend(s, left, right) {
2572   var len = (s.length + left | 0) + right | 0;
2573   var r = Caml_string.caml_create_string(len);
2574   var match = left < 0 ? /* tuple */[
2575       -left | 0,
2576       0
2577     ] : /* tuple */[
2578       0,
2579       left
2580     ];
2581   var dstoff = match[1];
2582   var srcoff = match[0];
2583   var cpylen = Pervasives.min(s.length - srcoff | 0, len - dstoff | 0);
2584   if (cpylen > 0) {
2585     Caml_string.caml_blit_bytes(s, srcoff, r, dstoff, cpylen);
2586   }
2587   return r;
2588 }
2589
2590 function fill(s, ofs, len, c) {
2591   if (ofs < 0 || len < 0 || ofs > (s.length - len | 0)) {
2592     throw [
2593           Caml_builtin_exceptions.invalid_argument,
2594           "String.fill / Bytes.fill"
2595         ];
2596   }
2597   else {
2598     return Caml_string.caml_fill_string(s, ofs, len, c);
2599   }
2600 }
2601
2602 function blit(s1, ofs1, s2, ofs2, len) {
2603   if (len < 0 || ofs1 < 0 || ofs1 > (s1.length - len | 0) || ofs2 < 0 || ofs2 > (s2.length - len | 0)) {
2604     throw [
2605           Caml_builtin_exceptions.invalid_argument,
2606           "Bytes.blit"
2607         ];
2608   }
2609   else {
2610     return Caml_string.caml_blit_bytes(s1, ofs1, s2, ofs2, len);
2611   }
2612 }
2613
2614 function blit_string(s1, ofs1, s2, ofs2, len) {
2615   if (len < 0 || ofs1 < 0 || ofs1 > (s1.length - len | 0) || ofs2 < 0 || ofs2 > (s2.length - len | 0)) {
2616     throw [
2617           Caml_builtin_exceptions.invalid_argument,
2618           "String.blit / Bytes.blit_string"
2619         ];
2620   }
2621   else {
2622     return Caml_string.caml_blit_string(s1, ofs1, s2, ofs2, len);
2623   }
2624 }
2625
2626 function iter(f, a) {
2627   for(var i = 0 ,i_finish = a.length - 1 | 0; i <= i_finish; ++i){
2628     Curry._1(f, a[i]);
2629   }
2630   return /* () */0;
2631 }
2632
2633 function iteri(f, a) {
2634   for(var i = 0 ,i_finish = a.length - 1 | 0; i <= i_finish; ++i){
2635     Curry._2(f, i, a[i]);
2636   }
2637   return /* () */0;
2638 }
2639
2640 function concat(sep, l) {
2641   if (l) {
2642     var hd = l[0];
2643     var num = [0];
2644     var len = [0];
2645     List.iter(function (s) {
2646           num[0] = num[0] + 1 | 0;
2647           len[0] = len[0] + s.length | 0;
2648           return /* () */0;
2649         }, l);
2650     var r = Caml_string.caml_create_string(len[0] + Caml_int32.imul(sep.length, num[0] - 1 | 0) | 0);
2651     Caml_string.caml_blit_bytes(hd, 0, r, 0, hd.length);
2652     var pos = [hd.length];
2653     List.iter(function (s) {
2654           Caml_string.caml_blit_bytes(sep, 0, r, pos[0], sep.length);
2655           pos[0] = pos[0] + sep.length | 0;
2656           Caml_string.caml_blit_bytes(s, 0, r, pos[0], s.length);
2657           pos[0] = pos[0] + s.length | 0;
2658           return /* () */0;
2659         }, l[1]);
2660     return r;
2661   }
2662   else {
2663     return empty;
2664   }
2665 }
2666
2667 function cat(a, b) {
2668   return a.concat(b);
2669 }
2670
2671 function is_space(param) {
2672   var switcher = param - 9 | 0;
2673   if (switcher > 4 || switcher < 0) {
2674     if (switcher !== 23) {
2675       return /* false */0;
2676     }
2677     else {
2678       return /* true */1;
2679     }
2680   }
2681   else if (switcher !== 2) {
2682     return /* true */1;
2683   }
2684   else {
2685     return /* false */0;
2686   }
2687 }
2688
2689 function trim(s) {
2690   var len = s.length;
2691   var i = 0;
2692   while(i < len && is_space(s[i])) {
2693     i = i + 1 | 0;
2694   };
2695   var j = len - 1 | 0;
2696   while(j >= i && is_space(s[j])) {
2697     j = j - 1 | 0;
2698   };
2699   if (j >= i) {
2700     return sub(s, i, (j - i | 0) + 1 | 0);
2701   }
2702   else {
2703     return empty;
2704   }
2705 }
2706
2707 function escaped(s) {
2708   var n = 0;
2709   for(var i = 0 ,i_finish = s.length - 1 | 0; i <= i_finish; ++i){
2710     var match = s[i];
2711     var $js;
2712     if (match >= 32) {
2713       var switcher = match - 34 | 0;
2714       $js = switcher > 58 || switcher < 0 ? (
2715           switcher >= 93 ? 4 : 1
2716         ) : (
2717           switcher > 57 || switcher < 1 ? 2 : 1
2718         );
2719     }
2720     else {
2721       $js = match >= 11 ? (
2722           match !== 13 ? 4 : 2
2723         ) : (
2724           match >= 8 ? 2 : 4
2725         );
2726     }
2727     n = n + $js | 0;
2728   }
2729   if (n === s.length) {
2730     return copy(s);
2731   }
2732   else {
2733     var s$prime = Caml_string.caml_create_string(n);
2734     n = 0;
2735     for(var i$1 = 0 ,i_finish$1 = s.length - 1 | 0; i$1 <= i_finish$1; ++i$1){
2736       var c = s[i$1];
2737       var exit = 0;
2738       if (c >= 35) {
2739         if (c !== 92) {
2740           if (c >= 127) {
2741             exit = 1;
2742           }
2743           else {
2744             s$prime[n] = c;
2745           }
2746         }
2747         else {
2748           exit = 2;
2749         }
2750       }
2751       else if (c >= 32) {
2752         if (c >= 34) {
2753           exit = 2;
2754         }
2755         else {
2756           s$prime[n] = c;
2757         }
2758       }
2759       else if (c >= 14) {
2760         exit = 1;
2761       }
2762       else {
2763         switch (c) {
2764           case 8 : 
2765               s$prime[n] = /* "\\" */92;
2766               n = n + 1 | 0;
2767               s$prime[n] = /* "b" */98;
2768               break;
2769           case 9 : 
2770               s$prime[n] = /* "\\" */92;
2771               n = n + 1 | 0;
2772               s$prime[n] = /* "t" */116;
2773               break;
2774           case 10 : 
2775               s$prime[n] = /* "\\" */92;
2776               n = n + 1 | 0;
2777               s$prime[n] = /* "n" */110;
2778               break;
2779           case 0 : 
2780           case 1 : 
2781           case 2 : 
2782           case 3 : 
2783           case 4 : 
2784           case 5 : 
2785           case 6 : 
2786           case 7 : 
2787           case 11 : 
2788           case 12 : 
2789               exit = 1;
2790               break;
2791           case 13 : 
2792               s$prime[n] = /* "\\" */92;
2793               n = n + 1 | 0;
2794               s$prime[n] = /* "r" */114;
2795               break;
2796           
2797         }
2798       }
2799       switch (exit) {
2800         case 1 : 
2801             s$prime[n] = /* "\\" */92;
2802             n = n + 1 | 0;
2803             s$prime[n] = 48 + (c / 100 | 0) | 0;
2804             n = n + 1 | 0;
2805             s$prime[n] = 48 + (c / 10 | 0) % 10 | 0;
2806             n = n + 1 | 0;
2807             s$prime[n] = 48 + c % 10 | 0;
2808             break;
2809         case 2 : 
2810             s$prime[n] = /* "\\" */92;
2811             n = n + 1 | 0;
2812             s$prime[n] = c;
2813             break;
2814         
2815       }
2816       n = n + 1 | 0;
2817     }
2818     return s$prime;
2819   }
2820 }
2821
2822 function map(f, s) {
2823   var l = s.length;
2824   if (l) {
2825     var r = Caml_string.caml_create_string(l);
2826     for(var i = 0 ,i_finish = l - 1 | 0; i <= i_finish; ++i){
2827       r[i] = Curry._1(f, s[i]);
2828     }
2829     return r;
2830   }
2831   else {
2832     return s;
2833   }
2834 }
2835
2836 function mapi(f, s) {
2837   var l = s.length;
2838   if (l) {
2839     var r = Caml_string.caml_create_string(l);
2840     for(var i = 0 ,i_finish = l - 1 | 0; i <= i_finish; ++i){
2841       r[i] = Curry._2(f, i, s[i]);
2842     }
2843     return r;
2844   }
2845   else {
2846     return s;
2847   }
2848 }
2849
2850 function uppercase(s) {
2851   return map(Char.uppercase, s);
2852 }
2853
2854 function lowercase(s) {
2855   return map(Char.lowercase, s);
2856 }
2857
2858 function apply1(f, s) {
2859   if (s.length) {
2860     var r = copy(s);
2861     r[0] = Curry._1(f, s[0]);
2862     return r;
2863   }
2864   else {
2865     return s;
2866   }
2867 }
2868
2869 function capitalize(s) {
2870   return apply1(Char.uppercase, s);
2871 }
2872
2873 function uncapitalize(s) {
2874   return apply1(Char.lowercase, s);
2875 }
2876
2877 function index_rec(s, lim, _i, c) {
2878   while(true) {
2879     var i = _i;
2880     if (i >= lim) {
2881       throw Caml_builtin_exceptions.not_found;
2882     }
2883     else if (s[i] === c) {
2884       return i;
2885     }
2886     else {
2887       _i = i + 1 | 0;
2888       continue ;
2889       
2890     }
2891   };
2892 }
2893
2894 function index(s, c) {
2895   return index_rec(s, s.length, 0, c);
2896 }
2897
2898 function index_from(s, i, c) {
2899   var l = s.length;
2900   if (i < 0 || i > l) {
2901     throw [
2902           Caml_builtin_exceptions.invalid_argument,
2903           "String.index_from / Bytes.index_from"
2904         ];
2905   }
2906   else {
2907     return index_rec(s, l, i, c);
2908   }
2909 }
2910
2911 function rindex_rec(s, _i, c) {
2912   while(true) {
2913     var i = _i;
2914     if (i < 0) {
2915       throw Caml_builtin_exceptions.not_found;
2916     }
2917     else if (s[i] === c) {
2918       return i;
2919     }
2920     else {
2921       _i = i - 1 | 0;
2922       continue ;
2923       
2924     }
2925   };
2926 }
2927
2928 function rindex(s, c) {
2929   return rindex_rec(s, s.length - 1 | 0, c);
2930 }
2931
2932 function rindex_from(s, i, c) {
2933   if (i < -1 || i >= s.length) {
2934     throw [
2935           Caml_builtin_exceptions.invalid_argument,
2936           "String.rindex_from / Bytes.rindex_from"
2937         ];
2938   }
2939   else {
2940     return rindex_rec(s, i, c);
2941   }
2942 }
2943
2944 function contains_from(s, i, c) {
2945   var l = s.length;
2946   if (i < 0 || i > l) {
2947     throw [
2948           Caml_builtin_exceptions.invalid_argument,
2949           "String.contains_from / Bytes.contains_from"
2950         ];
2951   }
2952   else {
2953     try {
2954       index_rec(s, l, i, c);
2955       return /* true */1;
2956     }
2957     catch (exn){
2958       if (exn === Caml_builtin_exceptions.not_found) {
2959         return /* false */0;
2960       }
2961       else {
2962         throw exn;
2963       }
2964     }
2965   }
2966 }
2967
2968 function contains(s, c) {
2969   return contains_from(s, 0, c);
2970 }
2971
2972 function rcontains_from(s, i, c) {
2973   if (i < 0 || i >= s.length) {
2974     throw [
2975           Caml_builtin_exceptions.invalid_argument,
2976           "String.rcontains_from / Bytes.rcontains_from"
2977         ];
2978   }
2979   else {
2980     try {
2981       rindex_rec(s, i, c);
2982       return /* true */1;
2983     }
2984     catch (exn){
2985       if (exn === Caml_builtin_exceptions.not_found) {
2986         return /* false */0;
2987       }
2988       else {
2989         throw exn;
2990       }
2991     }
2992   }
2993 }
2994
2995 var compare = Caml_obj.caml_compare;
2996
2997 var unsafe_to_string = Caml_string.bytes_to_string;
2998
2999 var unsafe_of_string = Caml_string.bytes_of_string;
3000
3001 exports.make             = make;
3002 exports.init             = init;
3003 exports.empty            = empty;
3004 exports.copy             = copy;
3005 exports.of_string        = of_string;
3006 exports.to_string        = to_string;
3007 exports.sub              = sub;
3008 exports.sub_string       = sub_string;
3009 exports.extend           = extend;
3010 exports.fill             = fill;
3011 exports.blit             = blit;
3012 exports.blit_string      = blit_string;
3013 exports.concat           = concat;
3014 exports.cat              = cat;
3015 exports.iter             = iter;
3016 exports.iteri            = iteri;
3017 exports.map              = map;
3018 exports.mapi             = mapi;
3019 exports.trim             = trim;
3020 exports.escaped          = escaped;
3021 exports.index            = index;
3022 exports.rindex           = rindex;
3023 exports.index_from       = index_from;
3024 exports.rindex_from      = rindex_from;
3025 exports.contains         = contains;
3026 exports.contains_from    = contains_from;
3027 exports.rcontains_from   = rcontains_from;
3028 exports.uppercase        = uppercase;
3029 exports.lowercase        = lowercase;
3030 exports.capitalize       = capitalize;
3031 exports.uncapitalize     = uncapitalize;
3032 exports.compare          = compare;
3033 exports.unsafe_to_string = unsafe_to_string;
3034 exports.unsafe_of_string = unsafe_of_string;
3035 /* No side effect */
3036 //////// end of bytes.js ////////
3037     return exports;
3038   };
3039
3040
3041   _registry['caml_array'] = function() {
3042     let exports = {};
3043 //////// start of caml_array.js ////////
3044 'use strict';
3045
3046
3047 function caml_array_sub(x, offset, len) {
3048   var result = new Array(len);
3049   var j = 0;
3050   var i = offset;
3051   while(j < len) {
3052     result[j] = x[i];
3053     j = j + 1 | 0;
3054     i = i + 1 | 0;
3055   };
3056   return result;
3057 }
3058
3059 function len(_acc, _l) {
3060   while(true) {
3061     var l = _l;
3062     var acc = _acc;
3063     if (l) {
3064       _l = l[1];
3065       _acc = l[0].length + acc | 0;
3066       continue ;
3067       
3068     }
3069     else {
3070       return acc;
3071     }
3072   };
3073 }
3074
3075 function fill(arr, _i, _l) {
3076   while(true) {
3077     var l = _l;
3078     var i = _i;
3079     if (l) {
3080       var x = l[0];
3081       var l$1 = x.length;
3082       var k = i;
3083       var j = 0;
3084       while(j < l$1) {
3085         arr[k] = x[j];
3086         k = k + 1 | 0;
3087         j = j + 1 | 0;
3088       };
3089       _l = l[1];
3090       _i = k;
3091       continue ;
3092       
3093     }
3094     else {
3095       return /* () */0;
3096     }
3097   };
3098 }
3099
3100 function caml_array_concat(l) {
3101   var v = len(0, l);
3102   var result = new Array(v);
3103   fill(result, 0, l);
3104   return result;
3105 }
3106
3107 function caml_make_vect(len, init) {
3108   var b = new Array(len);
3109   for(var i = 0 ,i_finish = len - 1 | 0; i <= i_finish; ++i){
3110     b[i] = init;
3111   }
3112   return b;
3113 }
3114
3115 function caml_array_blit(a1, i1, a2, i2, len) {
3116   if (i2 <= i1) {
3117     for(var j = 0 ,j_finish = len - 1 | 0; j <= j_finish; ++j){
3118       a2[j + i2 | 0] = a1[j + i1 | 0];
3119     }
3120     return /* () */0;
3121   }
3122   else {
3123     for(var j$1 = len - 1 | 0; j$1 >= 0; --j$1){
3124       a2[j$1 + i2 | 0] = a1[j$1 + i1 | 0];
3125     }
3126     return /* () */0;
3127   }
3128 }
3129
3130 exports.caml_array_sub    = caml_array_sub;
3131 exports.caml_array_concat = caml_array_concat;
3132 exports.caml_make_vect    = caml_make_vect;
3133 exports.caml_array_blit   = caml_array_blit;
3134 /* No side effect */
3135 //////// end of caml_array.js ////////
3136     return exports;
3137   };
3138
3139
3140   _registry['caml_builtin_exceptions'] = function() {
3141     let exports = {};
3142 //////// start of caml_builtin_exceptions.js ////////
3143 'use strict';
3144
3145
3146 var out_of_memory = /* tuple */[
3147   "Out_of_memory",
3148   0
3149 ];
3150
3151 var sys_error = /* tuple */[
3152   "Sys_error",
3153   -1
3154 ];
3155
3156 var failure = /* tuple */[
3157   "Failure",
3158   -2
3159 ];
3160
3161 var invalid_argument = /* tuple */[
3162   "Invalid_argument",
3163   -3
3164 ];
3165
3166 var end_of_file = /* tuple */[
3167   "End_of_file",
3168   -4
3169 ];
3170
3171 var division_by_zero = /* tuple */[
3172   "Division_by_zero",
3173   -5
3174 ];
3175
3176 var not_found = /* tuple */[
3177   "Not_found",
3178   -6
3179 ];
3180
3181 var match_failure = /* tuple */[
3182   "Match_failure",
3183   -7
3184 ];
3185
3186 var stack_overflow = /* tuple */[
3187   "Stack_overflow",
3188   -8
3189 ];
3190
3191 var sys_blocked_io = /* tuple */[
3192   "Sys_blocked_io",
3193   -9
3194 ];
3195
3196 var assert_failure = /* tuple */[
3197   "Assert_failure",
3198   -10
3199 ];
3200
3201 var undefined_recursive_module = /* tuple */[
3202   "Undefined_recursive_module",
3203   -11
3204 ];
3205
3206 exports.out_of_memory              = out_of_memory;
3207 exports.sys_error                  = sys_error;
3208 exports.failure                    = failure;
3209 exports.invalid_argument           = invalid_argument;
3210 exports.end_of_file                = end_of_file;
3211 exports.division_by_zero           = division_by_zero;
3212 exports.not_found                  = not_found;
3213 exports.match_failure              = match_failure;
3214 exports.stack_overflow             = stack_overflow;
3215 exports.sys_blocked_io             = sys_blocked_io;
3216 exports.assert_failure             = assert_failure;
3217 exports.undefined_recursive_module = undefined_recursive_module;
3218 /* No side effect */
3219 //////// end of caml_builtin_exceptions.js ////////
3220     return exports;
3221   };
3222
3223
3224   _registry['caml_bytes'] = function() {
3225     let exports = {};
3226 //////// start of caml_bytes.js ////////
3227 'use strict';
3228
3229 var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
3230
3231 function get(s, i) {
3232   if (i < 0 || i >= s.length) {
3233     throw [
3234           Caml_builtin_exceptions.invalid_argument,
3235           "index out of bounds"
3236         ];
3237   }
3238   else {
3239     return s[i];
3240   }
3241 }
3242
3243 exports.get = get;
3244 /* No side effect */
3245 //////// end of caml_bytes.js ////////
3246     return exports;
3247   };
3248
3249
3250   _registry['caml_exceptions'] = function() {
3251     let exports = {};
3252 //////// start of caml_exceptions.js ////////
3253 'use strict';
3254
3255
3256 var id = [0];
3257
3258 function caml_set_oo_id(b) {
3259   b[1] = id[0];
3260   id[0] += 1;
3261   return b;
3262 }
3263
3264 function get_id() {
3265   id[0] += 1;
3266   return id[0];
3267 }
3268
3269 function create(str) {
3270   var v_001 = get_id(/* () */0);
3271   var v = /* tuple */[
3272     str,
3273     v_001
3274   ];
3275   v.tag = 248;
3276   return v;
3277 }
3278
3279 exports.caml_set_oo_id = caml_set_oo_id;
3280 exports.get_id         = get_id;
3281 exports.create         = create;
3282 /* No side effect */
3283 //////// end of caml_exceptions.js ////////
3284     return exports;
3285   };
3286
3287
3288   _registry['caml_float'] = function() {
3289     let exports = {};
3290 //////// start of caml_float.js ////////
3291 'use strict';
3292
3293
3294 function caml_int32_float_of_bits(x) {
3295   var int32 = new Int32Array(/* array */[x]);
3296   var float32 = new Float32Array(int32.buffer);
3297   return float32[0];
3298 }
3299
3300 function caml_int32_bits_of_float(x) {
3301   var float32 = new Float32Array(/* float array */[x]);
3302   return new Int32Array(float32.buffer)[0];
3303 }
3304
3305 function caml_classify_float(x) {
3306   if (isFinite(x)) {
3307     if (Math.abs(x) >= 2.2250738585072014e-308) {
3308       return /* FP_normal */0;
3309     }
3310     else if (x !== 0) {
3311       return /* FP_subnormal */1;
3312     }
3313     else {
3314       return /* FP_zero */2;
3315     }
3316   }
3317   else if (isNaN(x)) {
3318     return /* FP_nan */4;
3319   }
3320   else {
3321     return /* FP_infinite */3;
3322   }
3323 }
3324
3325 function caml_modf_float(x) {
3326   if (isFinite(x)) {
3327     var neg = +(1 / x < 0);
3328     var x$1 = Math.abs(x);
3329     var i = Math.floor(x$1);
3330     var f = x$1 - i;
3331     if (neg) {
3332       return /* tuple */[
3333               -f,
3334               -i
3335             ];
3336     }
3337     else {
3338       return /* tuple */[
3339               f,
3340               i
3341             ];
3342     }
3343   }
3344   else if (isNaN(x)) {
3345     return /* tuple */[
3346             NaN,
3347             NaN
3348           ];
3349   }
3350   else {
3351     return /* tuple */[
3352             1 / x,
3353             x
3354           ];
3355   }
3356 }
3357
3358 var caml_ldexp_float = ( function (x,exp) {
3359     exp |= 0;
3360     if (exp > 1023) {
3361         exp -= 1023;
3362         x *= Math.pow(2, 1023);
3363         if (exp > 1023) {  // in case x is subnormal
3364             exp -= 1023;
3365             x *= Math.pow(2, 1023);
3366         }
3367     }
3368     if (exp < -1023) {
3369         exp += 1023;
3370         x *= Math.pow(2, -1023);
3371     }
3372     x *= Math.pow(2, exp);
3373     return x;
3374 }
3375 );
3376
3377 var caml_frexp_float = (function (x) {
3378     if ((x == 0) || !isFinite(x)) return [ x, 0];
3379     var neg = x < 0;
3380     if (neg) x = - x;
3381     var exp = Math.floor(Math.LOG2E*Math.log(x)) + 1;
3382     x *= Math.pow(2,-exp);
3383     if (x < 0.5) { x *= 2; exp -= 1; }
3384     if (neg) x = - x;
3385     return [x, exp];
3386 }
3387 );
3388
3389 function caml_float_compare(x, y) {
3390   if (x === y) {
3391     return 0;
3392   }
3393   else if (x < y) {
3394     return -1;
3395   }
3396   else if (x > y || x === x) {
3397     return 1;
3398   }
3399   else if (y === y) {
3400     return -1;
3401   }
3402   else {
3403     return 0;
3404   }
3405 }
3406
3407 function caml_copysign_float(x, y) {
3408   var x$1 = Math.abs(x);
3409   var y$1 = y === 0 ? 1 / y : y;
3410   if (y$1 < 0) {
3411     return -x$1;
3412   }
3413   else {
3414     return x$1;
3415   }
3416 }
3417
3418 function caml_expm1_float(x) {
3419   var y = Math.exp(x);
3420   var z = y - 1;
3421   if (Math.abs(x) > 1) {
3422     return z;
3423   }
3424   else if (z === 0) {
3425     return x;
3426   }
3427   else {
3428     return x * z / Math.log(y);
3429   }
3430 }
3431
3432 var caml_hypot_float = ( function (x, y) {
3433     var x0 = Math.abs(x), y0 = Math.abs(y);
3434     var a = Math.max(x0, y0), b = Math.min(x0,y0) / (a?a:1);
3435     return a * Math.sqrt(1 + b*b);
3436 }
3437 );
3438
3439 var caml_log10_float = ( function  (x) { 
3440    return Math.LOG10E * Math.log(x); }
3441 );
3442
3443 exports.caml_int32_float_of_bits = caml_int32_float_of_bits;
3444 exports.caml_int32_bits_of_float = caml_int32_bits_of_float;
3445 exports.caml_classify_float      = caml_classify_float;
3446 exports.caml_modf_float          = caml_modf_float;
3447 exports.caml_ldexp_float         = caml_ldexp_float;
3448 exports.caml_frexp_float         = caml_frexp_float;
3449 exports.caml_float_compare       = caml_float_compare;
3450 exports.caml_copysign_float      = caml_copysign_float;
3451 exports.caml_expm1_float         = caml_expm1_float;
3452 exports.caml_hypot_float         = caml_hypot_float;
3453 exports.caml_log10_float         = caml_log10_float;
3454 /* caml_ldexp_float Not a pure module */
3455 //////// end of caml_float.js ////////
3456     return exports;
3457   };
3458
3459
3460   _registry['caml_format'] = function() {
3461     let exports = {};
3462 //////// start of caml_format.js ////////
3463 'use strict';
3464
3465 var Curry                   = require("./curry");
3466 var Caml_int32              = require("./caml_int32");
3467 var Caml_int64              = require("./caml_int64");
3468 var Caml_utils              = require("./caml_utils");
3469 var Caml_string             = require("./caml_string");
3470 var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
3471
3472 function caml_failwith(s) {
3473   throw [
3474         Caml_builtin_exceptions.failure,
3475         s
3476       ];
3477 }
3478
3479 function parse_digit(c) {
3480   if (c >= 65) {
3481     if (c >= 97) {
3482       if (c >= 123) {
3483         return -1;
3484       }
3485       else {
3486         return c - 87 | 0;
3487       }
3488     }
3489     else if (c >= 91) {
3490       return -1;
3491     }
3492     else {
3493       return c - 55 | 0;
3494     }
3495   }
3496   else if (c > 57 || c < 48) {
3497     return -1;
3498   }
3499   else {
3500     return c - /* "0" */48 | 0;
3501   }
3502 }
3503
3504 function int_of_string_base(param) {
3505   switch (param) {
3506     case 0 : 
3507         return 8;
3508     case 1 : 
3509         return 16;
3510     case 2 : 
3511         return 10;
3512     case 3 : 
3513         return 2;
3514     
3515   }
3516 }
3517
3518 function parse_sign_and_base(s) {
3519   var sign = 1;
3520   var base = /* Dec */2;
3521   var i = 0;
3522   if (s[i] === "-") {
3523     sign = -1;
3524     i = i + 1 | 0;
3525   }
3526   var match = s.charCodeAt(i);
3527   var match$1 = s.charCodeAt(i + 1 | 0);
3528   if (match === 48) {
3529     if (match$1 >= 89) {
3530       if (match$1 !== 98) {
3531         if (match$1 !== 111) {
3532           if (match$1 === 120) {
3533             base = /* Hex */1;
3534             i = i + 2 | 0;
3535           }
3536           
3537         }
3538         else {
3539           base = /* Oct */0;
3540           i = i + 2 | 0;
3541         }
3542       }
3543       else {
3544         base = /* Bin */3;
3545         i = i + 2 | 0;
3546       }
3547     }
3548     else if (match$1 !== 66) {
3549       if (match$1 !== 79) {
3550         if (match$1 >= 88) {
3551           base = /* Hex */1;
3552           i = i + 2 | 0;
3553         }
3554         
3555       }
3556       else {
3557         base = /* Oct */0;
3558         i = i + 2 | 0;
3559       }
3560     }
3561     else {
3562       base = /* Bin */3;
3563       i = i + 2 | 0;
3564     }
3565   }
3566   return /* tuple */[
3567           i,
3568           sign,
3569           base
3570         ];
3571 }
3572
3573 function caml_int_of_string(s) {
3574   var match = parse_sign_and_base(s);
3575   var i = match[0];
3576   var base = int_of_string_base(match[2]);
3577   var threshold = 4294967295;
3578   var len = s.length;
3579   var c = i < len ? s.charCodeAt(i) : /* "\000" */0;
3580   var d = parse_digit(c);
3581   if (d < 0 || d >= base) {
3582     throw [
3583           Caml_builtin_exceptions.failure,
3584           "int_of_string"
3585         ];
3586   }
3587   var aux = function (_acc, _k) {
3588     while(true) {
3589       var k = _k;
3590       var acc = _acc;
3591       if (k === len) {
3592         return acc;
3593       }
3594       else {
3595         var a = s.charCodeAt(k);
3596         if (a === /* "_" */95) {
3597           _k = k + 1 | 0;
3598           continue ;
3599           
3600         }
3601         else {
3602           var v = parse_digit(a);
3603           if (v < 0 || v >= base) {
3604             throw [
3605                   Caml_builtin_exceptions.failure,
3606                   "int_of_string"
3607                 ];
3608           }
3609           else {
3610             var acc$1 = base * acc + v;
3611             if (acc$1 > threshold) {
3612               throw [
3613                     Caml_builtin_exceptions.failure,
3614                     "int_of_string"
3615                   ];
3616             }
3617             else {
3618               _k = k + 1 | 0;
3619               _acc = acc$1;
3620               continue ;
3621               
3622             }
3623           }
3624         }
3625       }
3626     };
3627   };
3628   var res = match[1] * aux(d, i + 1 | 0);
3629   var or_res = res | 0;
3630   if (base === 10 && res !== or_res) {
3631     throw [
3632           Caml_builtin_exceptions.failure,
3633           "int_of_string"
3634         ];
3635   }
3636   return or_res;
3637 }
3638
3639 function caml_int64_of_string(s) {
3640   var match = parse_sign_and_base(s);
3641   var hbase = match[2];
3642   var i = match[0];
3643   var base = Caml_int64.of_int32(int_of_string_base(hbase));
3644   var sign = Caml_int64.of_int32(match[1]);
3645   var threshold;
3646   switch (hbase) {
3647     case 0 : 
3648         threshold = /* int64 */[
3649           /* hi */536870911,
3650           /* lo */4294967295
3651         ];
3652         break;
3653     case 1 : 
3654         threshold = /* int64 */[
3655           /* hi */268435455,
3656           /* lo */4294967295
3657         ];
3658         break;
3659     case 2 : 
3660         threshold = /* int64 */[
3661           /* hi */429496729,
3662           /* lo */2576980377
3663         ];
3664         break;
3665     case 3 : 
3666         threshold = /* int64 */[
3667           /* hi */2147483647,
3668           /* lo */4294967295
3669         ];
3670         break;
3671     
3672   }
3673   var len = s.length;
3674   var c = i < len ? s.charCodeAt(i) : /* "\000" */0;
3675   var d = Caml_int64.of_int32(parse_digit(c));
3676   if (Caml_int64.lt(d, /* int64 */[
3677           /* hi */0,
3678           /* lo */0
3679         ]) || Caml_int64.ge(d, base)) {
3680     throw [
3681           Caml_builtin_exceptions.failure,
3682           "int64_of_string"
3683         ];
3684   }
3685   var aux = function (_acc, _k) {
3686     while(true) {
3687       var k = _k;
3688       var acc = _acc;
3689       if (k === len) {
3690         return acc;
3691       }
3692       else {
3693         var a = s.charCodeAt(k);
3694         if (a === /* "_" */95) {
3695           _k = k + 1 | 0;
3696           continue ;
3697           
3698         }
3699         else {
3700           var v = Caml_int64.of_int32(parse_digit(a));
3701           if (Caml_int64.lt(v, /* int64 */[
3702                   /* hi */0,
3703                   /* lo */0
3704                 ]) || Caml_int64.ge(v, base)) {
3705             throw [
3706                   Caml_builtin_exceptions.failure,
3707                   "int64_of_string"
3708                 ];
3709           }
3710           else {
3711             var acc$1 = Caml_int64.add(Caml_int64.mul(base, acc), v);
3712             if (Caml_int64.gt(acc$1, threshold)) {
3713               throw [
3714                     Caml_builtin_exceptions.failure,
3715                     "int64_of_string"
3716                   ];
3717             }
3718             else {
3719               _k = k + 1 | 0;
3720               _acc = acc$1;
3721               continue ;
3722               
3723             }
3724           }
3725         }
3726       }
3727     };
3728   };
3729   var res = Caml_int64.mul(sign, aux(d, i + 1 | 0));
3730   var or_res_000 = /* hi */res[0] | /* hi */0;
3731   var or_res_001 = /* lo */(res[1] >>> 0);
3732   var or_res = /* int64 */[
3733     or_res_000,
3734     or_res_001
3735   ];
3736   if (Caml_int64.eq(base, /* int64 */[
3737           /* hi */0,
3738           /* lo */10
3739         ]) && Caml_int64.neq(res, or_res)) {
3740     throw [
3741           Caml_builtin_exceptions.failure,
3742           "int64_of_string"
3743         ];
3744   }
3745   return or_res;
3746 }
3747
3748 function int_of_base(param) {
3749   switch (param) {
3750     case 0 : 
3751         return 8;
3752     case 1 : 
3753         return 16;
3754     case 2 : 
3755         return 10;
3756     
3757   }
3758 }
3759
3760 function lowercase(c) {
3761   if (c >= /* "A" */65 && c <= /* "Z" */90 || c >= /* "\192" */192 && c <= /* "\214" */214 || c >= /* "\216" */216 && c <= /* "\222" */222) {
3762     return c + 32 | 0;
3763   }
3764   else {
3765     return c;
3766   }
3767 }
3768
3769 function parse_format(fmt) {
3770   var len = fmt.length;
3771   if (len > 31) {
3772     throw [
3773           Caml_builtin_exceptions.invalid_argument,
3774           "format_int: format too long"
3775         ];
3776   }
3777   var f = /* record */[
3778     /* justify */"+",
3779     /* signstyle */"-",
3780     /* filter */" ",
3781     /* alternate : false */0,
3782     /* base : Dec */2,
3783     /* signedconv : false */0,
3784     /* width */0,
3785     /* uppercase : false */0,
3786     /* sign */1,
3787     /* prec */-1,
3788     /* conv */"f"
3789   ];
3790   var _i = 0;
3791   while(true) {
3792     var i = _i;
3793     if (i >= len) {
3794       return f;
3795     }
3796     else {
3797       var c = fmt.charCodeAt(i);
3798       var exit = 0;
3799       if (c >= 69) {
3800         if (c >= 88) {
3801           if (c >= 121) {
3802             exit = 1;
3803           }
3804           else {
3805             switch (c - 88 | 0) {
3806               case 0 : 
3807                   f[/* base */4] = /* Hex */1;
3808                   f[/* uppercase */7] = /* true */1;
3809                   _i = i + 1 | 0;
3810                   continue ;
3811                   case 13 : 
3812               case 14 : 
3813               case 15 : 
3814                   exit = 5;
3815                   break;
3816               case 12 : 
3817               case 17 : 
3818                   exit = 4;
3819                   break;
3820               case 23 : 
3821                   f[/* base */4] = /* Oct */0;
3822                   _i = i + 1 | 0;
3823                   continue ;
3824                   case 29 : 
3825                   f[/* base */4] = /* Dec */2;
3826                   _i = i + 1 | 0;
3827                   continue ;
3828                   case 1 : 
3829               case 2 : 
3830               case 3 : 
3831               case 4 : 
3832               case 5 : 
3833               case 6 : 
3834               case 7 : 
3835               case 8 : 
3836               case 9 : 
3837               case 10 : 
3838               case 11 : 
3839               case 16 : 
3840               case 18 : 
3841               case 19 : 
3842               case 20 : 
3843               case 21 : 
3844               case 22 : 
3845               case 24 : 
3846               case 25 : 
3847               case 26 : 
3848               case 27 : 
3849               case 28 : 
3850               case 30 : 
3851               case 31 : 
3852                   exit = 1;
3853                   break;
3854               case 32 : 
3855                   f[/* base */4] = /* Hex */1;
3856                   _i = i + 1 | 0;
3857                   continue ;
3858                   
3859             }
3860           }
3861         }
3862         else if (c >= 72) {
3863           exit = 1;
3864         }
3865         else {
3866           f[/* signedconv */5] = /* true */1;
3867           f[/* uppercase */7] = /* true */1;
3868           f[/* conv */10] = String.fromCharCode(lowercase(c));
3869           _i = i + 1 | 0;
3870           continue ;
3871           
3872         }
3873       }
3874       else {
3875         var switcher = c - 32 | 0;
3876         if (switcher > 25 || switcher < 0) {
3877           exit = 1;
3878         }
3879         else {
3880           switch (switcher) {
3881             case 3 : 
3882                 f[/* alternate */3] = /* true */1;
3883                 _i = i + 1 | 0;
3884                 continue ;
3885                 case 0 : 
3886             case 11 : 
3887                 exit = 2;
3888                 break;
3889             case 13 : 
3890                 f[/* justify */0] = "-";
3891                 _i = i + 1 | 0;
3892                 continue ;
3893                 case 14 : 
3894                 f[/* prec */9] = 0;
3895                 var j = i + 1 | 0;
3896                 while((function(j){
3897                     return function () {
3898                       var w = fmt.charCodeAt(j) - /* "0" */48 | 0;
3899                       return +(w >= 0 && w <= 9);
3900                     }
3901                     }(j))()) {
3902                   f[/* prec */9] = (Caml_int32.imul(f[/* prec */9], 10) + fmt.charCodeAt(j) | 0) - /* "0" */48 | 0;
3903                   j = j + 1 | 0;
3904                 };
3905                 _i = j;
3906                 continue ;
3907                 case 1 : 
3908             case 2 : 
3909             case 4 : 
3910             case 5 : 
3911             case 6 : 
3912             case 7 : 
3913             case 8 : 
3914             case 9 : 
3915             case 10 : 
3916             case 12 : 
3917             case 15 : 
3918                 exit = 1;
3919                 break;
3920             case 16 : 
3921                 f[/* filter */2] = "0";
3922                 _i = i + 1 | 0;
3923                 continue ;
3924                 case 17 : 
3925             case 18 : 
3926             case 19 : 
3927             case 20 : 
3928             case 21 : 
3929             case 22 : 
3930             case 23 : 
3931             case 24 : 
3932             case 25 : 
3933                 exit = 3;
3934                 break;
3935             
3936           }
3937         }
3938       }
3939       switch (exit) {
3940         case 1 : 
3941             _i = i + 1 | 0;
3942             continue ;
3943             case 2 : 
3944             f[/* signstyle */1] = String.fromCharCode(c);
3945             _i = i + 1 | 0;
3946             continue ;
3947             case 3 : 
3948             f[/* width */6] = 0;
3949             var j$1 = i;
3950             while((function(j$1){
3951                 return function () {
3952                   var w = fmt.charCodeAt(j$1) - /* "0" */48 | 0;
3953                   return +(w >= 0 && w <= 9);
3954                 }
3955                 }(j$1))()) {
3956               f[/* width */6] = (Caml_int32.imul(f[/* width */6], 10) + fmt.charCodeAt(j$1) | 0) - /* "0" */48 | 0;
3957               j$1 = j$1 + 1 | 0;
3958             };
3959             _i = j$1;
3960             continue ;
3961             case 4 : 
3962             f[/* signedconv */5] = /* true */1;
3963             f[/* base */4] = /* Dec */2;
3964             _i = i + 1 | 0;
3965             continue ;
3966             case 5 : 
3967             f[/* signedconv */5] = /* true */1;
3968             f[/* conv */10] = String.fromCharCode(c);
3969             _i = i + 1 | 0;
3970             continue ;
3971             
3972       }
3973     }
3974   };
3975 }
3976
3977 function finish_formatting(param, rawbuffer) {
3978   var justify = param[/* justify */0];
3979   var signstyle = param[/* signstyle */1];
3980   var filter = param[/* filter */2];
3981   var alternate = param[/* alternate */3];
3982   var base = param[/* base */4];
3983   var signedconv = param[/* signedconv */5];
3984   var width = param[/* width */6];
3985   var uppercase = param[/* uppercase */7];
3986   var sign = param[/* sign */8];
3987   var len = rawbuffer.length;
3988   if (signedconv && (sign < 0 || signstyle !== "-")) {
3989     len = len + 1 | 0;
3990   }
3991   if (alternate) {
3992     if (base) {
3993       if (base === /* Hex */1) {
3994         len = len + 2 | 0;
3995       }
3996       
3997     }
3998     else {
3999       len = len + 1 | 0;
4000     }
4001   }
4002   var buffer = "";
4003   if (justify === "+" && filter === " ") {
4004     for(var i = len ,i_finish = width - 1 | 0; i <= i_finish; ++i){
4005       buffer = buffer + filter;
4006     }
4007   }
4008   if (signedconv) {
4009     if (sign < 0) {
4010       buffer = buffer + "-";
4011     }
4012     else if (signstyle !== "-") {
4013       buffer = buffer + signstyle;
4014     }
4015     
4016   }
4017   if (alternate && base === /* Oct */0) {
4018     buffer = buffer + "0";
4019   }
4020   if (alternate && base === /* Hex */1) {
4021     buffer = buffer + "0x";
4022   }
4023   if (justify === "+" && filter === "0") {
4024     for(var i$1 = len ,i_finish$1 = width - 1 | 0; i$1 <= i_finish$1; ++i$1){
4025       buffer = buffer + filter;
4026     }
4027   }
4028   buffer = uppercase ? buffer + rawbuffer.toUpperCase() : buffer + rawbuffer;
4029   if (justify === "-") {
4030     for(var i$2 = len ,i_finish$2 = width - 1 | 0; i$2 <= i_finish$2; ++i$2){
4031       buffer = buffer + " ";
4032     }
4033   }
4034   return buffer;
4035 }
4036
4037 function caml_format_int(fmt, i) {
4038   if (fmt === "%d") {
4039     return "" + i;
4040   }
4041   else {
4042     var f = parse_format(fmt);
4043     var f$1 = f;
4044     var i$1 = i;
4045     var i$2 = i$1 < 0 ? (
4046         f$1[/* signedconv */5] ? (f$1[/* sign */8] = -1, -i$1) : (i$1 >>> 0)
4047       ) : i$1;
4048     var s = i$2.toString(int_of_base(f$1[/* base */4]));
4049     if (f$1[/* prec */9] >= 0) {
4050       f$1[/* filter */2] = " ";
4051       var n = f$1[/* prec */9] - s.length | 0;
4052       if (n > 0) {
4053         s = Caml_utils.repeat(n, "0") + s;
4054       }
4055       
4056     }
4057     return finish_formatting(f$1, s);
4058   }
4059 }
4060
4061 function caml_int64_format(fmt, x) {
4062   var f = parse_format(fmt);
4063   var x$1 = f[/* signedconv */5] && Caml_int64.lt(x, /* int64 */[
4064         /* hi */0,
4065         /* lo */0
4066       ]) ? (f[/* sign */8] = -1, Caml_int64.neg(x)) : x;
4067   var s = "";
4068   var match = f[/* base */4];
4069   switch (match) {
4070     case 0 : 
4071         var wbase = /* int64 */[
4072           /* hi */0,
4073           /* lo */8
4074         ];
4075         var cvtbl = "01234567";
4076         if (Caml_int64.lt(x$1, /* int64 */[
4077                 /* hi */0,
4078                 /* lo */0
4079               ])) {
4080           var y = Caml_int64.discard_sign(x$1);
4081           var match$1 = Caml_int64.div_mod(y, wbase);
4082           var quotient = Caml_int64.add(/* int64 */[
4083                 /* hi */268435456,
4084                 /* lo */0
4085               ], match$1[0]);
4086           var modulus = match$1[1];
4087           s = Caml_string.js_string_of_char(cvtbl.charCodeAt(modulus[1] | 0)) + s;
4088           while(Caml_int64.neq(quotient, /* int64 */[
4089                   /* hi */0,
4090                   /* lo */0
4091                 ])) {
4092             var match$2 = Caml_int64.div_mod(quotient, wbase);
4093             quotient = match$2[0];
4094             modulus = match$2[1];
4095             s = Caml_string.js_string_of_char(cvtbl.charCodeAt(modulus[1] | 0)) + s;
4096           };
4097         }
4098         else {
4099           var match$3 = Caml_int64.div_mod(x$1, wbase);
4100           var quotient$1 = match$3[0];
4101           var modulus$1 = match$3[1];
4102           s = Caml_string.js_string_of_char(cvtbl.charCodeAt(modulus$1[1] | 0)) + s;
4103           while(Caml_int64.neq(quotient$1, /* int64 */[
4104                   /* hi */0,
4105                   /* lo */0
4106                 ])) {
4107             var match$4 = Caml_int64.div_mod(quotient$1, wbase);
4108             quotient$1 = match$4[0];
4109             modulus$1 = match$4[1];
4110             s = Caml_string.js_string_of_char(cvtbl.charCodeAt(modulus$1[1] | 0)) + s;
4111           };
4112         }
4113         break;
4114     case 1 : 
4115         s = Caml_int64.to_hex(x$1) + s;
4116         break;
4117     case 2 : 
4118         var wbase$1 = /* int64 */[
4119           /* hi */0,
4120           /* lo */10
4121         ];
4122         var cvtbl$1 = "0123456789";
4123         if (Caml_int64.lt(x$1, /* int64 */[
4124                 /* hi */0,
4125                 /* lo */0
4126               ])) {
4127           var y$1 = Caml_int64.discard_sign(x$1);
4128           var match$5 = Caml_int64.div_mod(y$1, wbase$1);
4129           var match$6 = Caml_int64.div_mod(Caml_int64.add(/* int64 */[
4130                     /* hi */0,
4131                     /* lo */8
4132                   ], match$5[1]), wbase$1);
4133           var quotient$2 = Caml_int64.add(Caml_int64.add(/* int64 */[
4134                     /* hi */214748364,
4135                     /* lo */3435973836
4136                   ], match$5[0]), match$6[0]);
4137           var modulus$2 = match$6[1];
4138           s = Caml_string.js_string_of_char(cvtbl$1.charCodeAt(modulus$2[1] | 0)) + s;
4139           while(Caml_int64.neq(quotient$2, /* int64 */[
4140                   /* hi */0,
4141                   /* lo */0
4142                 ])) {
4143             var match$7 = Caml_int64.div_mod(quotient$2, wbase$1);
4144             quotient$2 = match$7[0];
4145             modulus$2 = match$7[1];
4146             s = Caml_string.js_string_of_char(cvtbl$1.charCodeAt(modulus$2[1] | 0)) + s;
4147           };
4148         }
4149         else {
4150           var match$8 = Caml_int64.div_mod(x$1, wbase$1);
4151           var quotient$3 = match$8[0];
4152           var modulus$3 = match$8[1];
4153           s = Caml_string.js_string_of_char(cvtbl$1.charCodeAt(modulus$3[1] | 0)) + s;
4154           while(Caml_int64.neq(quotient$3, /* int64 */[
4155                   /* hi */0,
4156                   /* lo */0
4157                 ])) {
4158             var match$9 = Caml_int64.div_mod(quotient$3, wbase$1);
4159             quotient$3 = match$9[0];
4160             modulus$3 = match$9[1];
4161             s = Caml_string.js_string_of_char(cvtbl$1.charCodeAt(modulus$3[1] | 0)) + s;
4162           };
4163         }
4164         break;
4165     
4166   }
4167   if (f[/* prec */9] >= 0) {
4168     f[/* filter */2] = " ";
4169     var n = f[/* prec */9] - s.length | 0;
4170     if (n > 0) {
4171       s = Caml_utils.repeat(n, "0") + s;
4172     }
4173     
4174   }
4175   return finish_formatting(f, s);
4176 }
4177
4178 function caml_format_float(fmt, x) {
4179   var f = parse_format(fmt);
4180   var prec = f[/* prec */9] < 0 ? 6 : f[/* prec */9];
4181   var x$1 = x < 0 ? (f[/* sign */8] = -1, -x) : x;
4182   var s = "";
4183   if (isNaN(x$1)) {
4184     s = "nan";
4185     f[/* filter */2] = " ";
4186   }
4187   else if (isFinite(x$1)) {
4188     var match = f[/* conv */10];
4189     switch (match) {
4190       case "e" : 
4191           s = x$1.toExponential(prec);
4192           var i = s.length;
4193           if (s[i - 3 | 0] === "e") {
4194             s = s.slice(0, i - 1 | 0) + ("0" + s.slice(i - 1 | 0));
4195           }
4196           break;
4197       case "f" : 
4198           s = x$1.toFixed(prec);
4199           break;