{"version":3, "file":"calc.js", "sourceRoot":"", "names": ["opt", "rest", "rest$0", "rest$1", "rest$2", "rest$3", "rest$4", "rest$5", "rest$6", "rest$7", "ty", "rest$8", "ty1", "rest$9", "rest$10", "rest$11", "rest$12", "rest$13", "fmtty1", "fmtty2", "ty2", "fmt1", "fmt2", "pad", "pad$0", "prec", "pad$1", "iconv", "prec$0", "pad$2", "iconv$0", "prec$1", "pad$3", "iconv$1", "prec$2", "pad$4", "iconv$2", "prec$3", "pad$5", "fconv", "str", "chr", "fmtty", "pad$6", "fmtty$0", "pad$7", "rest$14", "rest$15", "rest$16", "fmting_lit", "rest$17", "fmting_gen", "rest$18", "rest$19", "char_set", "width_opt", "rest$20", "counter", "rest$21", "rest$22", "ign", "rest$23", "f", "arity", "failwith", "s", "invalid_arg", "max", "x", "y", "abs", "max_int", "_e_", "s1", "s2", "l1", "l2", "_h_", "tl", "hd", "stdout", "stderr", "flush_all", "iter", "l", "a", "output_string", "oc", "exit_function", "at_exit", "g", "do_at_exit", "r", "accu", "accu$0", "l$0", "l$1", "accu$1", "b", "n", "make", "c", "len", "ofs", "ofs1", "ofs2", "lim", "i", "i$0", "i$1", "sep", "num", "pos", "tbl", "state", "buf", "result", "lexbuf", "i1", "i2", "blk", "closure", "e", "n$0", "n$1", "more", "new_len", "new_buffer", "new_position", "init_size", "overhead", "min_len", "new_str", "str_len", "formatting_lit", "str$0", "sub_fmtty", "sub_fmtty$0", "de", "ed", "af", "fa", "de$0", "ed$0", "af$0", "fa$0", "de$1", "ed$1", "af$1", "fa$1", "de$2", "ed$2", "af$2", "fa$2", "de$3", "ed$3", "af$3", "fa$3", "de$4", "ed$4", "af$4", "fa$4", "de$5", "ed$5", "af$5", "fa$5", "de$6", "ed$6", "af$6", "fa$6", "de$7", "ed$7", "af$7", "fa$7", "de$8", "ed$8", "af$8", "fa$8", "jd", "dj", "ga", "ag", "de$9", "ed$9", "af$9", "fa$9", "de$10", "ed$10", "af$10", "fa$10", "de$11", "ed$11", "af$11", "fa$11", "de$12", "ed$12", "af$12", "fa$12", "de$13", "ed$13", "af$13", "fa$13", "match", "rest2", "rest2$0", "rest2$1", "rest2$2", "rest2$3", "rest2$4", "rest2$5", "rest2$6", "rest2$7", "rest2$8", "ty22", "ty21", "f4", "f2", "rest2$9", "rest2$10", "rest2$11", "rest2$12", "rest2$13", "w", "padty", "padty$0", "p", "fmt", "fmtty_rest", "fmt_rest", "fmt$0", "fmtty_rest$0", "fmt_rest$0", "fmtty$1", "fmt$1", "fmt_rest$1", "fmtty_rest$1", "fmtty$2", "fmt$2", "fmt_rest$2", "fmtty_rest$2", "fmtty$3", "fmt$3", "fmt_rest$3", "fmtty_rest$3", "fmtty$4", "fmt$4", "fmt_rest$4", "fmtty_rest$4", "fmtty$5", "fmt$5", "fmt_rest$5", "fmtty_rest$5", "fmtty$6", "fmt$6", "fmt_rest$6", "fmtty_rest$6", "fmtty$7", "fmt$7", "fmt_rest$7", "fmtty_rest$7", "fmtty$8", "fmt$8", "fmtty_rest$8", "fmt_rest$8", "fmtty$9", "fmt$9", "fmt_rest$9", "fmtty$10", "fmt$10", "fmt_rest$10", "fmtty$11", "fmt$11", "fmt_rest$11", "fmtty$12", "fmt$12", "fmtty_rest$9", "fmt_rest$12", "pad_opt", "fmtty$13", "fmt$13", "fmtty_rest$10", "sub_fmtty1", "fmt_rest$13", "sub_fmtty$1", "pad_opt$0", "fmtty$14", "fmt$14", "fmtty_rest$11", "fmt_rest$14", "fmtty$15", "fmt$15", "fmtty_rest$12", "fmt_rest$15", "fmtty$16", "fmt$16", "fmt_rest$16", "fmtty$17", "fmt$17", "fmt_rest$17", "formatting_gen", "fmtty3", "fmt3", "str$1", "fmt1$0", "fmtty2$0", "fmt2$0", "fmtty3$0", "fmt3$0", "fmtty_rest$13", "fmt_rest$18", "fmtty$18", "fmt$18", "fmtty_rest$14", "fmt_rest$19", "fmtty$19", "fmt$19", "fmtty_rest$15", "fmt_rest$20", "fmtty$20", "fmt$20", "fmtty_rest$16", "fmtty$21", "fmt$21", "sub_fmtty$2", "pad_opt$1", "sub_fmtty$3", "pad_opt$2", "fmtty$22", "fmt$22", "sub_fmtty$4", "sub_fmtty_rest", "sub_fmtty_rest$0", "sub_fmtty_rest$1", "sub_fmtty_rest$2", "sub_fmtty_rest$3", "sub_fmtty_rest$4", "sub_fmtty_rest$5", "sub_fmtty_rest$6", "sub_fmtty_rest$7", "sub_fmtty_rest$8", "sub_fmtty_rest$9", "sub_fmtty_rest$10", "sub_fmtty_rest$11", "sub_fmtty_rest$12", "sub_fmtty_rest$13", "sub_fmtty_rest$14", "sub2_fmtty", "sub_fmtty_rest$15", "sub2_fmtty$0", "sub_fmtty_rest$16", "sub2_fmtty$1", "sub1_fmtty", "sub_fmtty_rest$17", "sub2_fmtty$2", "sub1_fmtty$0", "sub_fmtty_rest$18", "sub_fmtty_rest$19", "sub_fmtty_rest$20", "sub_fmtty_rest$21", "sub_fmtty_rest$22", "sub_fmtty_rest$23", "sub_fmtty_rest$24", "sub_fmtty_rest$25", "sub_fmtty_rest$26", "width", "width$0", "res", "res$1", "res$0", "c$1", "i$2", "c$0", "seps", "symb", "k", "o", "acc", "k$0", "acc$0", "new_acc", "s$0", "p$0", "p$1", "acc$1", "acc$2", "acc$3", "acc$4", "k$3", "koc", "kacc", "k$1", "k$4", "k$2", "trans", "arity$0", "p$2", "p$3", "msg", "p$4", "invalid_box", "parse_spaces", "parse_lword", "j", "j$0", "j$1", "parse_int", "wstart", "wend", "box_name", "nstart", "nend", "indent", "exp_end", "box_type", "printers", "register_printer", "fn", "hash", "params", "seed$0", "seed", "h", "init", "indexfun", "odata", "osize", "nsize", "ndata", "insert_bucket", "data", "key", "nidx", "d$0", "d", "b$0", "histo", "info", "bucket", "remove_bucket", "next", "rest1", "d1", "k1", "d2", "k2", "rest3", "d3", "k3", "find_in_bucket", "replace_bucket", "initial_size", "sth", "random", "x$0", "curval", "newval", "newval30", "add_queue", "q", "cell", "take_queue", "pp_enqueue", "token", "pp_infinity", "pp_output_string", "pp_output_newline", "pp_output_spaces", "break_new_line", "offset", "real_indent", "break_line", "break_same_line", "pp_force_break_line", "bl_ty", "pp_skip_token", "size", "format_pp_token", "tabs", "add_tab", "ls", "ls$0", "tags", "tag_name", "marker", "off", "off$0", "insertion_point", "tabs$0", "find", "tab", "ty$0", "off$1", "insertion_point$0", "offset$0", "bl_type", "tbox", "tag_name$0", "marker$0", "advance_loop", "tok", "size$0", "advance_left", "enqueue_advance", "enqueue_string_as", "q_elem", "scan_stack_bottom", "clear_scan_stack", "set_size", "queue_elem", "left_tot", "t", "scan_push", "pp_open_box_gen", "br_ty", "elem", "pp_close_box", "pp_flush_queue", "pp_print_as_size", "pp_print_as", "isize", "pp_print_char", "pp_print_flush", "pp_print_break", "pp_print_cut", "blank_line", "default_pp_mark_open_tag", "default_pp_mark_close_tag", "default_pp_print_open_tag", "default_pp_print_close_tag", "make_formatter", "output", "flush", "pp_q", "sys_tok", "sys_scan_stack", "ppf", "formatter_of_out_channel", "formatter_of_buffer", "stdbuf", "std_formatter", "print_flush", "compute_tag", "tag_acc", "len$0", "output_acc", "bty", "f$0", "p$5", "p$6", "fprintf", "printf", "jsoo_obj", "undefined$0", "name", "exn", "slot", "object_constructor", "array_length", "jsoo_self", "obj", "module$0", "dest", "t2", "x2", "t1", "x1", "make_room", "slen0", "reqlen", "slen", "write_stringlit", "add", "json_error", "read_junk", "ocaml_lex_state", "ocaml_lex_state$0", "hex", "write_special", "src", "start", "stop", "ob", "finish_string", "write_string", "dst", "write_null", "write_bool", "max_digits", "write_digits", "pos$0", "write_int", "float_needs_period", "iter2", "f_elt", "f_sep", "y$0", "write_json", "s$1", "s$2", "write_std_json", "to_string", "std$0", "sth$0", "ob$0", "std", "read_junk$0", "read_junk$1", "arg1", "arg0", "evar", "arg0$0", "arg1$0", "arg0$1", "aty", "aty$0", "a$0", "aty$1", "ex", "walk", "ex2", "ex1", "ex$0", "st", "rt", "re", "v", "cstr", "cstr1", "cstr2", "e2", "e1", "e$0", "env", "pp_v", "opt$0", "pp_sep", "opt$1", "param$0", "x$1", "l2$0", "env1", "env2", "env1$0", "env2$0", "arg2", "arg1$1", "arg0$2", "arg2$0", "arg1$2", "arg0$3", "arg2$1", "arg1$3", "arg0$4", "skel", "skel2", "skel1", "je", "skel$0", "skel$1", "skel2$0", "skel1$0", "j$2", "skel$2", "je$0", "judge", "judge_e", "loop", "env2$1", "e2$1", "aty2$0", "e2$0", "env$0", "aty1", "aty2", "env$1", "cstr$0", "env$2", "a$1", "ty_dom", "aty$2", "env$3", "aty$3", "skel$3", "aty22", "ty21$0", "ty2$0", "cstr$2", "st$1", "ty2$1", "ty1$0", "st$2", "st$0", "cstr$1", "menhir_env$0", "menhir_stack$2", "menhir_s$2", "v$3", "menhir_stack$3", "tok$2", "menhir_s$3", "menhir_stack$4", "menhir_stack", "menhir_s", "v$0", "menhir_s$0", "menhir_stack$0", "v$1", "tok$0", "menhir_env", "menhir_s$1", "menhir_stack$1", "tok$1", "v$2", "v$4", "menhir_s$4", "menhir_s$5", "menhir_stack$5", "menhir_s$6", "menhir_stack$6", "menhir_env$1", "menhir_env$2", "menhir_env$3", "menhir_stack$7", "menhir_stack$8", "menhir_env$4", "v$5", "xs", "lexer", "ocaml_lex_state$1", "id", "skel_ret_to_yojson", "infer_ret_to_yojson", "ret", "infer", "deriv"], "mappings": "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", "sources": ["/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/stdlib.js", "/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/mlString.js", "/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/ieee_754.js", "/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/int64.js", "/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/jslib_js_of_ocaml.js", "/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/lexing.js", "/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/md5.js", "/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/io.js", "/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/fs.js", "/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/unix.js", "/Users/nishida/.opam/4.02.3/lib/js_of_ocaml/jslib.js", "/Users/nishida/.opam/4.02.3/lib/ocaml/hashtbl.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/camlinternalFormatBasics.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/pervasives.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/list.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/char.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/bytes.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/string.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/sys.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/lexing.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/camlinternalLazy.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/buffer.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/camlinternalFormat.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/printf.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/printexc.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/random.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/digest.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/array.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/format.ml", "/Users/nishida/.opam/4.02.3/build/js_of_ocaml.2.8/lib/js.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/callback.ml", "/Users/nishida/.opam/4.02.3/build/biniou.1.0.9/bi_share.ml", "/Users/nishida/.opam/4.02.3/build/biniou.1.0.9/bi_outbuf.ml", "/Users/nishida/.opam/4.02.3/build/yojson.1.3.2/write.ml", "/Users/nishida/.opam/4.02.3/build/yojson.1.3.2/common.ml", "/Users/nishida/.opam/4.02.3/build/yojson.1.3.2/read.mll", "/Users/nishida/.opam/4.02.3/build/yojson.1.3.2/read.ml", "/Users/nishida/Workspace/lambdaI/src/_build/type.ml", "/Users/nishida/Workspace/lambdaI/src/_build/inference.ml", "/Users/nishida/Workspace/lambdaI/src/_build/subst.ml", "/Users/nishida/Workspace/lambdaI/src/_build/constraint.ml", "/Users/nishida/Workspace/lambdaI/src/_build/term.ml", "/Users/nishida/Workspace/lambdaI/src/_build/env.ml", "/Users/nishida/Workspace/lambdaI/src/_build/deriv.ml", "/Users/nishida/Workspace/lambdaI/src/_build/parser.ml", "/Users/nishida/Workspace/lambdaI/src/_build/lexer.ml", "/Users/nishida/Workspace/lambdaI/src/_build/lexer.mll", "/Users/nishida/Workspace/lambdaI/src/_build/calc.ml", "/Users/nishida/.opam/4.02.3/lib/ocaml/std_exit.ml"], "sourcesContent": ["// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Core\n\n//Provides: raw_array_sub\nfunction raw_array_sub (a,i,l) {\n var b = new Array(l);\n for(var j = 0; j < l; j++) b[j] = a[i+j];\n return b\n}\n\n//Provides: raw_array_copy\nfunction raw_array_copy (a) {\n var l = a.length;\n var b = new Array(l);\n for(var i = 0; i < l; i++ ) b[i] = a[i];\n return b\n}\n\n//Provides: raw_array_cons\nfunction raw_array_cons (a,x) {\n var l = a.length;\n var b = new Array(l+1);\n b[0]=x;\n for(var i = 1; i <= l; i++ ) b[i] = a[i-1];\n return b\n}\n\n//Provides: raw_array_append_one\nfunction raw_array_append_one(a,x) {\n var l = a.length;\n var b = new Array(l+1);\n var i = 0;\n for(; i < l; i++ ) b[i] = a[i];\n b[i]=x;\n return b\n}\n\n//Provides: caml_call_gen (const, shallow)\n//Requires: raw_array_sub\n//Requires: raw_array_append_one\nfunction caml_call_gen(f, args) {\n if(f.fun)\n return caml_call_gen(f.fun, args);\n var n = f.length;\n var argsLen = args.length;\n var d = n - argsLen;\n if (d == 0)\n return f.apply(null, args);\n else if (d < 0)\n return caml_call_gen(f.apply(null,\n raw_array_sub(args,0,n)),\n raw_array_sub(args,n,argsLen - n));\n else\n return function (x){ return caml_call_gen(f, raw_array_append_one(args,x)); };\n}\n\n//Provides: caml_named_values\nvar caml_named_values = {};\n\n//Provides: caml_register_named_value (const,const)\n//Requires: caml_named_values, caml_bytes_of_string\nfunction caml_register_named_value(nm,v) {\n caml_named_values[caml_bytes_of_string(nm)] = v;\n return 0;\n}\n\n//Provides: caml_named_value\n//Requires: caml_named_values\nfunction caml_named_value(nm) {\n return caml_named_values[nm]\n}\n\n//Provides: caml_global_data\nvar caml_global_data = [0];\n\n//Provides: caml_register_global (const, shallow, const)\n//Requires: caml_global_data\nfunction caml_register_global (n, v, name_opt) {\n caml_global_data[n + 1] = v;\n if(name_opt) caml_global_data[name_opt] = v;\n}\n\n//Provides: caml_get_global_data mutable\n//Requires: caml_global_data\nfunction caml_get_global_data () { return caml_global_data; }\n\n//Raise exception\n\n\n//Provides: caml_raise_constant (const)\n//Version: < 4.02\nfunction caml_raise_constant (tag) { throw [0, tag]; }\n\n//Provides: caml_raise_constant (const)\n//Version: >= 4.02\nfunction caml_raise_constant (tag) { throw tag; }\n\n//Provides: caml_return_exn_constant (const)\n//Version: < 4.02\nfunction caml_return_exn_constant (tag) { return [0, tag]; }\n\n//Provides: caml_return_exn_constant (const)\n//Version: >= 4.02\nfunction caml_return_exn_constant (tag) { return tag; }\n\n//Provides: caml_raise_with_arg (const, const)\nfunction caml_raise_with_arg (tag, arg) { throw [0, tag, arg]; }\n\n//Provides: caml_raise_with_string (const, const)\n//Requires: caml_raise_with_arg,caml_new_string\nfunction caml_raise_with_string (tag, msg) {\n caml_raise_with_arg (tag, caml_new_string (msg));\n}\n\n//Provides: caml_raise_sys_error (const)\n//Requires: caml_raise_with_string, caml_global_data\nfunction caml_raise_sys_error (msg) {\n caml_raise_with_string(caml_global_data.Sys_error, msg);\n}\n\n//Provides: caml_failwith (const)\n//Requires: caml_raise_with_string, caml_global_data\nfunction caml_failwith (msg) {\n caml_raise_with_string(caml_global_data.Failure, msg);\n}\n\n//Provides: caml_wrap_exception const (const)\n//Requires: caml_global_data,caml_js_to_string,caml_named_value\n//Requires: caml_return_exn_constant\nfunction caml_wrap_exception(e) {\n if(e instanceof Array) return e;\n //Stack_overflow: chrome, safari\n if(joo_global_object.RangeError\n && e instanceof joo_global_object.RangeError\n && e.message\n && e.message.match(/maximum call stack/i))\n return caml_return_exn_constant(caml_global_data.Stack_overflow);\n //Stack_overflow: firefox\n if(joo_global_object.InternalError\n && e instanceof joo_global_object.InternalError\n && e.message\n && e.message.match(/too much recursion/i))\n return caml_return_exn_constant(caml_global_data.Stack_overflow);\n //Wrap Error in Js.Error exception\n if(e instanceof joo_global_object.Error)\n return [0,caml_named_value(\"jsError\"),e];\n //fallback: wrapped in Failure\n return [0,caml_global_data.Failure,caml_js_to_string (String(e))];\n}\n\n// Experimental\n//Provides: caml_exn_with_js_backtrace\n//Requires: caml_global_data\nfunction caml_exn_with_js_backtrace(exn, force) {\n if(!exn.js_error || force) exn.js_error = new joo_global_object.Error(\"Js exception containing backtrace\");\n return exn;\n}\n//Provides: caml_js_error_of_exception\nfunction caml_js_error_of_exception(exn) {\n if(exn.js_error) { return exn.js_error; }\n return null;\n}\n\n//Provides: caml_invalid_argument (const)\n//Requires: caml_raise_with_string, caml_global_data\nfunction caml_invalid_argument (msg) {\n caml_raise_with_string(caml_global_data.Invalid_argument, msg);\n}\n\n//Provides: caml_raise_end_of_file\n//Requires: caml_raise_constant, caml_global_data\nfunction caml_raise_end_of_file () {\n caml_raise_constant(caml_global_data.End_of_file);\n}\n\n//Provides: caml_raise_zero_divide\n//Requires: caml_raise_constant, caml_global_data\nfunction caml_raise_zero_divide () {\n caml_raise_constant(caml_global_data.Division_by_zero);\n}\n\n//Provides: caml_raise_not_found\n//Requires: caml_raise_constant, caml_global_data\nfunction caml_raise_not_found () {\n caml_raise_constant(caml_global_data.Not_found); }\n\n\n//Provides: caml_array_bound_error\n//Requires: caml_invalid_argument\nfunction caml_array_bound_error () {\n caml_invalid_argument(\"index out of bounds\");\n}\n\n//Provides: caml_update_dummy\nfunction caml_update_dummy (x, y) {\n if( typeof y===\"function\" ) { x.fun = y; return 0; }\n if( y.fun ) { x.fun = y.fun; return 0; }\n var i = y.length; while (i--) x[i] = y[i]; return 0;\n}\n\n//Provides: caml_obj_is_block const (const)\nfunction caml_obj_is_block (x) { return +(x instanceof Array); }\n//Provides: caml_obj_tag const (const)\n//Requires: MlString\nfunction caml_obj_tag (x) { return (x instanceof Array)?x[0]:(x instanceof MlString)?252:1000; }\n//Provides: caml_obj_set_tag (mutable, const)\nfunction caml_obj_set_tag (x, tag) { x[0] = tag; return 0; }\n//Provides: caml_obj_block const (const,const)\nfunction caml_obj_block (tag, size) {\n var o = new Array(size+1);\n o[0]=tag;\n for (var i = 1; i <= size; i++) o[i] = 0;\n return o;\n}\n//Provides: caml_obj_dup mutable (const)\nfunction caml_obj_dup (x) {\n var l = x.length;\n var a = new Array(l);\n for(var i = 0; i < l; i++ ) a[i] = x[i];\n return a;\n}\n//Provides: caml_obj_truncate (mutable, const)\n//Requires: caml_invalid_argument\nfunction caml_obj_truncate (x, s) {\n if (s<=0 || s + 1 > x.length)\n caml_invalid_argument (\"Obj.truncate\");\n if (x.length != s + 1) x.length = s + 1;\n return 0;\n}\n\n//Provides: caml_lazy_make_forward const (const)\nfunction caml_lazy_make_forward (v) { return [250, v]; }\n\n//Provides: caml_mul const\nif (!Math.imul)\n Math.imul =\n function (x,y)\n { y |= 0; return ((((x >> 16) * y) << 16) + (x & 0xffff) * y)|0; };\nvar caml_mul = Math.imul;\n\n//slightly slower\n// function mul32(x,y) {\n// var xlo = x & 0xffff;\n// var xhi = x - xlo;\n// return (((xhi * y) |0) + xlo * y)|0;\n// }\n\n//Provides: caml_div\n//Requires: caml_raise_zero_divide\nfunction caml_div(x,y) {\n if (y == 0) caml_raise_zero_divide ();\n return (x/y)|0;\n}\n\n//Provides: caml_mod\n//Requires: caml_raise_zero_divide\nfunction caml_mod(x,y) {\n if (y == 0) caml_raise_zero_divide ();\n return x%y;\n}\n\n///////////// Pervasive\n//Provides: caml_array_set (mutable, const, const)\n//Requires: caml_array_bound_error\nfunction caml_array_set (array, index, newval) {\n if ((index < 0) || (index >= array.length - 1)) caml_array_bound_error();\n array[index+1]=newval; return 0;\n}\n\n//Provides: caml_array_get mutable (const, const)\n//Requires: caml_array_bound_error\nfunction caml_array_get (array, index) {\n if ((index < 0) || (index >= array.length - 1)) caml_array_bound_error();\n return array[index+1];\n}\n\n//Provides: caml_check_bound (const, const)\n//Requires: caml_array_bound_error\nfunction caml_check_bound (array, index) {\n if (index >>> 0 >= array.length - 1) caml_array_bound_error();\n return array;\n}\n\n//Provides: caml_make_vect const (const, const)\nfunction caml_make_vect (len, init) {\n var len = len + 1 | 0;\n var b = new Array(len);\n b[0]=0;\n for (var i = 1; i < len; i++) b[i] = init;\n return b;\n}\n\n//Provides: caml_make_float_vect const (const)\nfunction caml_make_float_vect(len){\n var len = len + 1 | 0;\n var b = new Array(len);\n b[0]=254;\n for (var i = 1; i < len; i++) b[i] = 0;\n return b\n}\n\n//Provides: caml_compare_val (const, const, const)\n//Requires: MlString, caml_int64_compare, caml_int_compare, caml_string_compare\n//Requires: caml_invalid_argument\nfunction caml_compare_val (a, b, total) {\n var stack = [];\n for(;;) {\n if (!(total && a === b)) {\n if (a instanceof MlString) {\n if (b instanceof MlString) {\n if (a !== b) {\n\u0009\u0009var x = caml_string_compare(a, b);\n\u0009\u0009if (x != 0) return x;\n\u0009 }\n } else\n // Should not happen\n return 1;\n } else if (a instanceof Array && a[0] === (a[0]|0)) {\n var ta = a[0];\n // ignore double_array_tag\n if (ta === 254) ta=0;\n // Forward object\n if (ta === 250) {\n a = a[1];\n continue;\n } else if (b instanceof Array && b[0] === (b[0]|0)) {\n var tb = b[0];\n // ignore double_array_tag\n if (tb === 254) tb=0;\n // Forward object\n if (tb === 250) {\n b = b[1];\n continue;\n } else if (ta != tb) {\n return (ta < tb)?-1:1;\n } else {\n switch (ta) {\n case 248: {\n\u0009\u0009// Object\n\u0009\u0009var x = caml_int_compare(a[2], b[2]);\n\u0009\u0009if (x != 0) return x;\n\u0009\u0009break;\n\u0009 }\n case 251: {\n caml_invalid_argument(\"equal: abstract value\");\n }\n case 255: {\n\u0009\u0009// Int64\n\u0009\u0009var x = caml_int64_compare(a, b);\n\u0009\u0009if (x != 0) return x;\n\u0009\u0009break;\n\u0009 }\n default:\n if (a.length != b.length) return (a.length < b.length)?-1:1;\n if (a.length > 1) stack.push(a, b, 1);\n }\n }\n } else\n return 1;\n } else if (b instanceof MlString ||\n (b instanceof Array && b[0] === (b[0]|0))) {\n return -1;\n } else if (typeof a != \"number\" && a && a.compare) {\n return a.compare(b,total);\n } else if (typeof a == \"function\") {\n caml_invalid_argument(\"equal: functional value\");\n } else {\n if (a < b) return -1;\n if (a > b) return 1;\n if (a != b) {\n if (!total) return NaN;\n if (a == a) return 1;\n if (b == b) return -1;\n }\n }\n }\n if (stack.length == 0) return 0;\n var i = stack.pop();\n b = stack.pop();\n a = stack.pop();\n if (i + 1 < a.length) stack.push(a, b, i + 1);\n a = a[i];\n b = b[i];\n }\n}\n//Provides: caml_compare (const, const)\n//Requires: caml_compare_val\nfunction caml_compare (a, b) { return caml_compare_val (a, b, true); }\n//Provides: caml_int_compare mutable (const, const)\nfunction caml_int_compare (a, b) {\n if (a < b) return (-1); if (a == b) return 0; return 1;\n}\n//Provides: caml_equal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_equal (x, y) { return +(caml_compare_val(x,y,false) == 0); }\n//Provides: caml_notequal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_notequal (x, y) { return +(caml_compare_val(x,y,false) != 0); }\n//Provides: caml_greaterequal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_greaterequal (x, y) { return +(caml_compare_val(x,y,false) >= 0); }\n//Provides: caml_greaterthan mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_greaterthan (x, y) { return +(caml_compare_val(x,y,false) > 0); }\n//Provides: caml_lessequal mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_lessequal (x, y) { return +(caml_compare_val(x,y,false) <= 0); }\n//Provides: caml_lessthan mutable (const, const)\n//Requires: caml_compare_val\nfunction caml_lessthan (x, y) { return +(caml_compare_val(x,y,false) < 0); }\n\n//Provides: caml_parse_sign_and_base\n//Requires: caml_string_unsafe_get, caml_ml_string_length\nfunction caml_parse_sign_and_base (s) {\n var i = 0, len = caml_ml_string_length(s), base = 10,\n sign = (len > 0 && caml_string_unsafe_get(s,0) == 45)?(i++,-1):1;\n if (i + 1 < len && caml_string_unsafe_get(s, i) == 48)\n switch (caml_string_unsafe_get(s, i + 1)) {\n case 120: case 88: base = 16; i += 2; break;\n case 111: case 79: base = 8; i += 2; break;\n case 98: case 66: base = 2; i += 2; break;\n }\n return [i, sign, base];\n}\n\n//Provides: caml_parse_digit\nfunction caml_parse_digit(c) {\n if (c >= 48 && c <= 57) return c - 48;\n if (c >= 65 && c <= 90) return c - 55;\n if (c >= 97 && c <= 122) return c - 87;\n return -1;\n}\n\n//Provides: caml_int_of_string (const)\n//Requires: caml_ml_string_length, caml_string_unsafe_get\n//Requires: caml_parse_sign_and_base, caml_parse_digit, caml_failwith\nfunction caml_int_of_string (s) {\n var r = caml_parse_sign_and_base (s);\n var i = r[0], sign = r[1], base = r[2];\n var len = caml_ml_string_length(s);\n var threshold = -1 >>> 0;\n var c = (i < len)?caml_string_unsafe_get(s, i):0;\n var d = caml_parse_digit(c);\n if (d < 0 || d >= base) caml_failwith(\"int_of_string\");\n var res = d;\n for (i++;i= base) break;\n res = base * res + d;\n if (res > threshold) caml_failwith(\"int_of_string\");\n }\n if (i != len) caml_failwith(\"int_of_string\");\n // For base different from 10, we expect an unsigned representation,\n // hence any value of 'res' (less than 'threshold') is acceptable.\n // But we have to convert the result back to a signed integer.\n res = sign * res;\n if ((base == 10) && ((res | 0) != res))\n /* Signed representation expected, allow -2^(nbits-1) to 2^(nbits-1) - 1 */\n caml_failwith(\"int_of_string\");\n return res | 0;\n}\n\n//Provides: caml_float_of_string (const)\n//Requires: caml_failwith, caml_bytes_of_string\nfunction caml_float_of_string(s) {\n var res;\n s = caml_bytes_of_string (s);\n res = +s;\n if ((s.length > 0) && (res === res)) return res;\n s = s.replace(/_/g,\"\");\n res = +s;\n if (((s.length > 0) && (res === res)) || /^[+-]?nan$/i.test(s)) return res;\n var m = /^ *([+-]?)0x([0-9a-f]+)\\.?([0-9a-f]*)p([+-]?[0-9]+)/i.exec(s);\n// 1 2 3 4\n if(m){\n var m3 = m[3].replace(/0+$/,'');\n var mantissa = parseInt(m[1] + m[2] + m3, 16);\n var exponent = (m[4]|0) - 4*m3.length;\n res = mantissa * Math.pow(2, exponent);\n return res;\n }\n if(/^\\+?inf(inity)?$/i.test(s)) return Infinity;\n if(/^-inf(inity)?$/i.test(s)) return -Infinity;\n caml_failwith(\"float_of_string\");\n}\n\n//Provides: caml_is_printable const (const)\nfunction caml_is_printable(c) { return +(c > 31 && c < 127); }\n\n///////////// Format\n//Provides: caml_parse_format\n//Requires: caml_bytes_of_string, caml_invalid_argument\nfunction caml_parse_format (fmt) {\n fmt = caml_bytes_of_string(fmt);\n var len = fmt.length;\n if (len > 31) caml_invalid_argument(\"format_int: format too long\");\n var f =\n { justify:'+', signstyle:'-', filler:' ', alternate:false,\n base:0, signedconv:false, width:0, uppercase:false,\n sign:1, prec:-1, conv:'f' };\n for (var i = 0; i < len; i++) {\n var c = fmt.charAt(i);\n switch (c) {\n case '-':\n f.justify = '-'; break;\n case '+': case ' ':\n f.signstyle = c; break;\n case '0':\n f.filler = '0'; break;\n case '#':\n f.alternate = true; break;\n case '1': case '2': case '3': case '4': case '5':\n case '6': case '7': case '8': case '9':\n f.width = 0;\n while (c=fmt.charCodeAt(i) - 48, c >= 0 && c <= 9) {\n f.width = f.width * 10 + c; i++\n }\n i--;\n break;\n case '.':\n f.prec = 0;\n i++;\n while (c=fmt.charCodeAt(i) - 48, c >= 0 && c <= 9) {\n f.prec = f.prec * 10 + c; i++\n }\n i--;\n case 'd': case 'i':\n f.signedconv = true; /* fallthrough */\n case 'u':\n f.base = 10; break;\n case 'x':\n f.base = 16; break;\n case 'X':\n f.base = 16; f.uppercase = true; break;\n case 'o':\n f.base = 8; break;\n case 'e': case 'f': case 'g':\n f.signedconv = true; f.conv = c; break;\n case 'E': case 'F': case 'G':\n f.signedconv = true; f.uppercase = true;\n f.conv = c.toLowerCase (); break;\n }\n }\n return f;\n}\n\n//Provides: caml_finish_formatting\n//Requires: caml_new_string\nfunction caml_finish_formatting(f, rawbuffer) {\n if (f.uppercase) rawbuffer = rawbuffer.toUpperCase();\n var len = rawbuffer.length;\n /* Adjust len to reflect additional chars (sign, etc) */\n if (f.signedconv && (f.sign < 0 || f.signstyle != '-')) len++;\n if (f.alternate) {\n if (f.base == 8) len += 1;\n if (f.base == 16) len += 2;\n }\n /* Do the formatting */\n var buffer = \"\";\n if (f.justify == '+' && f.filler == ' ')\n for (var i = len; i < f.width; i++) buffer += ' ';\n if (f.signedconv) {\n if (f.sign < 0) buffer += '-';\n else if (f.signstyle != '-') buffer += f.signstyle;\n }\n if (f.alternate && f.base == 8) buffer += '0';\n if (f.alternate && f.base == 16) buffer += \"0x\";\n if (f.justify == '+' && f.filler == '0')\n for (var i = len; i < f.width; i++) buffer += '0';\n buffer += rawbuffer;\n if (f.justify == '-')\n for (var i = len; i < f.width; i++) buffer += ' ';\n return caml_new_string (buffer);\n}\n\n//Provides: caml_format_int const (const, const)\n//Requires: caml_parse_format, caml_finish_formatting, caml_str_repeat\n//Requires: caml_new_string, caml_bytes_of_string\nfunction caml_format_int(fmt, i) {\n if (caml_bytes_of_string(fmt) == \"%d\") return caml_new_string(\"\"+i);\n var f = caml_parse_format(fmt);\n if (i < 0) { if (f.signedconv) { f.sign = -1; i = -i; } else i >>>= 0; }\n var s = i.toString(f.base);\n if (f.prec >= 0) {\n f.filler = ' ';\n var n = f.prec - s.length;\n if (n > 0) s = caml_str_repeat (n, '0') + s;\n }\n return caml_finish_formatting(f, s);\n}\n\n//Provides: caml_format_float const\n//Requires: caml_parse_format, caml_finish_formatting\nfunction caml_format_float (fmt, x) {\n var s, f = caml_parse_format(fmt);\n var prec = (f.prec < 0)?6:f.prec;\n if (x < 0 || (x == 0 && 1/x == -Infinity)) { f.sign = -1; x = -x; }\n if (isNaN(x)) { s = \"nan\"; f.filler = ' '; }\n else if (!isFinite(x)) { s = \"inf\"; f.filler = ' '; }\n else\n switch (f.conv) {\n case 'e':\n var s = x.toExponential(prec);\n // exponent should be at least two digits\n var i = s.length;\n if (s.charAt(i - 3) == 'e')\n s = s.slice (0, i - 1) + '0' + s.slice (i - 1);\n break;\n case 'f':\n s = x.toFixed(prec); break;\n case 'g':\n prec = prec?prec:1;\n s = x.toExponential(prec - 1);\n var j = s.indexOf('e');\n var exp = +s.slice(j + 1);\n if (exp < -4 || x >= 1e21 || x.toFixed(0).length > prec) {\n // remove trailing zeroes\n var i = j - 1; while (s.charAt(i) == '0') i--;\n if (s.charAt(i) == '.') i--;\n s = s.slice(0, i + 1) + s.slice(j);\n i = s.length;\n if (s.charAt(i - 3) == 'e')\n s = s.slice (0, i - 1) + '0' + s.slice (i - 1);\n break;\n } else {\n var p = prec;\n if (exp < 0) { p -= exp + 1; s = x.toFixed(p); }\n else while (s = x.toFixed(p), s.length > prec + 1) p--;\n if (p) {\n // remove trailing zeroes\n var i = s.length - 1; while (s.charAt(i) == '0') i--;\n if (s.charAt(i) == '.') i--;\n s = s.slice(0, i + 1);\n }\n }\n break;\n }\n return caml_finish_formatting(f, s);\n}\n\n///////////// Hashtbl\n//Provides: caml_hash_univ_param mutable\n//Requires: MlString, caml_convert_string_to_bytes\n//Requires: caml_int64_to_bytes, caml_int64_bits_of_float\nfunction caml_hash_univ_param (count, limit, obj) {\n var hash_accu = 0;\n function hash_aux (obj) {\n limit --;\n if (count < 0 || limit < 0) return;\n if (obj instanceof Array && obj[0] === (obj[0]|0)) {\n switch (obj[0]) {\n case 248:\n // Object\n count --;\n hash_accu = (hash_accu * 65599 + obj[2]) | 0;\n break;\n case 250:\n // Forward\n limit++; hash_aux(obj); break;\n case 255:\n // Int64\n count --;\n hash_accu = (hash_accu * 65599 + obj[1] + (obj[2] << 24)) | 0;\n break;\n default:\n count --;\n hash_accu = (hash_accu * 19 + obj[0]) | 0;\n for (var i = obj.length - 1; i > 0; i--) hash_aux (obj[i]);\n }\n } else if (obj instanceof MlString) {\n count --;\n switch (obj.t & 6) {\n default: /* PARTIAL */\n caml_convert_string_to_bytes(obj);\n case 0: /* BYTES */\n for (var b = obj.c, l = obj.l, i = 0; i < l; i++)\n hash_accu = (hash_accu * 19 + b.charCodeAt(i)) | 0;\n break;\n case 2: /* ARRAY */\n for (var a = obj.c, l = obj.l, i = 0; i < l; i++)\n hash_accu = (hash_accu * 19 + a[i]) | 0;\n }\n } else if (obj === (obj|0)) {\n // Integer\n count --;\n hash_accu = (hash_accu * 65599 + obj) | 0;\n } else if (obj === +obj) {\n // Float\n count--;\n var p = caml_int64_to_bytes (caml_int64_bits_of_float (obj));\n for (var i = 7; i >= 0; i--) hash_accu = (hash_accu * 19 + p[i]) | 0;\n }\n }\n hash_aux (obj);\n return hash_accu & 0x3FFFFFFF;\n}\n\n//function ROTL32(x,n) { return ((x << n) | (x >>> (32-n))); }\n//Provides: caml_hash_mix_int\n//Requires: caml_mul\nfunction caml_hash_mix_int(h,d) {\n d = caml_mul(d, 0xcc9e2d51|0);\n d = ((d << 15) | (d >>> (32-15))); // ROTL32(d, 15);\n d = caml_mul(d, 0x1b873593);\n h ^= d;\n h = ((h << 13) | (h >>> (32-13))); //ROTL32(h, 13);\n return (((h + (h << 2))|0) + (0xe6546b64|0))|0;\n}\n\n//Provides: caml_hash_mix_final\n//Requires: caml_mul\nfunction caml_hash_mix_final(h) {\n h ^= h >>> 16;\n h = caml_mul (h, 0x85ebca6b|0);\n h ^= h >>> 13;\n h = caml_mul (h, 0xc2b2ae35|0);\n h ^= h >>> 16;\n return h;\n}\n\n//Provides: caml_hash_mix_float\n//Requires: caml_hash_mix_int, caml_int64_bits_of_float\nfunction caml_hash_mix_float (h, v0) {\n var v = caml_int64_bits_of_float (v0);\n var lo = v[1] | (v[2] << 24);\n var hi = (v[2] >>> 8) | (v[3] << 16);\n h = caml_hash_mix_int(h, lo);\n h = caml_hash_mix_int(h, hi);\n return h;\n}\n//Provides: caml_hash_mix_int64\n//Requires: caml_hash_mix_int\nfunction caml_hash_mix_int64 (h, v) {\n var lo = v[1] | (v[2] << 24);\n var hi = (v[2] >>> 8) | (v[3] << 16);\n h = caml_hash_mix_int(h, hi ^ lo);\n return h;\n}\n\n//Provides: caml_hash_mix_string_str\n//Requires: caml_hash_mix_int\nfunction caml_hash_mix_string_str(h, s) {\n var len = s.length, i, w;\n for (i = 0; i + 4 <= len; i += 4) {\n w = s.charCodeAt(i)\n | (s.charCodeAt(i+1) << 8)\n | (s.charCodeAt(i+2) << 16)\n | (s.charCodeAt(i+3) << 24);\n h = caml_hash_mix_int(h, w);\n }\n w = 0;\n switch (len & 3) {\n case 3: w = s.charCodeAt(i+2) << 16;\n case 2: w |= s.charCodeAt(i+1) << 8;\n case 1: w |= s.charCodeAt(i);\n h = caml_hash_mix_int(h, w);\n default:\n }\n h ^= len;\n return h;\n}\n\n//Provides: caml_hash_mix_string_arr\n//Requires: caml_hash_mix_int\nfunction caml_hash_mix_string_arr(h, s) {\n var len = s.length, i, w;\n for (i = 0; i + 4 <= len; i += 4) {\n w = s[i]\n | (s[i+1] << 8)\n | (s[i+2] << 16)\n | (s[i+3] << 24);\n h = caml_hash_mix_int(h, w);\n }\n w = 0;\n switch (len & 3) {\n case 3: w = s[i+2] << 16;\n case 2: w |= s[i+1] << 8;\n case 1: w |= s[i];\n h = caml_hash_mix_int(h, w);\n default:\n }\n h ^= len;\n return h;\n}\n\n//Provides: caml_hash_mix_string\n//Requires: caml_convert_string_to_bytes\n//Requires: caml_hash_mix_string_str\n//Requires: caml_hash_mix_string_arr\nfunction caml_hash_mix_string(h, v) {\n switch (v.t & 6) {\n default:\n caml_convert_string_to_bytes (v);\n case 0: /* BYTES */\n h = caml_hash_mix_string_str(h, v.c);\n break;\n case 2: /* ARRAY */\n h = caml_hash_mix_string_arr(h, v.c);\n }\n return h\n}\n\n\n//Provides: caml_hash mutable\n//Requires: MlString\n//Requires: caml_int64_bits_of_float, caml_hash_mix_int, caml_hash_mix_final\n//Requires: caml_hash_mix_int64, caml_hash_mix_float, caml_hash_mix_string\nvar HASH_QUEUE_SIZE = 256;\nfunction caml_hash (count, limit, seed, obj) {\n var queue, rd, wr, sz, num, h, v, i, len;\n sz = limit;\n if (sz < 0 || sz > HASH_QUEUE_SIZE) sz = HASH_QUEUE_SIZE;\n num = count;\n h = seed;\n queue = [obj]; rd = 0; wr = 1;\n while (rd < wr && num > 0) {\n v = queue[rd++];\n if (v instanceof Array && v[0] === (v[0]|0)) {\n switch (v[0]) {\n case 248:\n // Object\n h = caml_hash_mix_int(h, v[2]);\n num--;\n break;\n case 250:\n // Forward\n queue[--rd] = v[1];\n break;\n case 255:\n // Int64\n h = caml_hash_mix_int64 (h, v);\n num --;\n break;\n default:\n var tag = ((v.length - 1) << 10) | v[0];\n h = caml_hash_mix_int(h, tag);\n for (i = 1, len = v.length; i < len; i++) {\n if (wr >= sz) break;\n queue[wr++] = v[i];\n }\n break;\n }\n } else if (v instanceof MlString) {\n h = caml_hash_mix_string(h,v)\n num--;\n } else if (v === (v|0)) {\n // Integer\n h = caml_hash_mix_int(h, v+v+1);\n num--;\n } else if (v === +v) {\n // Float\n h = caml_hash_mix_float(h,v);\n num--;\n }\n }\n h = caml_hash_mix_final(h);\n return h & 0x3FFFFFFF;\n}\n\n///////////// Sys\n//Provides: caml_sys_time mutable\nvar caml_initial_time = new Date() * 0.001;\nfunction caml_sys_time () { return new Date() * 0.001 - caml_initial_time; }\n//Provides: caml_sys_get_config const\n//Requires: caml_new_string\nfunction caml_sys_get_config () {\n return [0, caml_new_string(\"Unix\"), 32, 0];\n}\n\n//Provides: caml_sys_const_backend_type const\n//Requires: caml_new_string\nfunction caml_sys_const_backend_type () {\n return [0, caml_new_string(\"js_of_ocaml\")];\n}\n\n\n//Provides: caml_sys_random_seed mutable\n//Version: < 4.00\n//The function needs to return an array since OCaml 4.0...\nfunction caml_sys_random_seed () {\n var x = new Date()^0xffffffff*Math.random();\n return x;\n}\n\n//Provides: caml_sys_random_seed mutable\n//Version: >= 4.00\n//The function needs to return an array since OCaml 4.0...\nfunction caml_sys_random_seed () {\n var x = new Date()^0xffffffff*Math.random();\n return [0,x];\n}\n\n\n\n//Provides: caml_sys_const_big_endian const\nfunction caml_sys_const_big_endian () { return 0; }\n//Provides: caml_sys_const_word_size const\nfunction caml_sys_const_word_size () { return 32; }\n//Provides: caml_sys_const_int_size const\nfunction caml_sys_const_int_size () { return 32; }\n\n//Provides: caml_sys_const_max_wosize const\n// max_int / 4 so that the following does not overflow\n//let max_string_length = word_size / 8 * max_array_length - 1;;\nfunction caml_sys_const_max_wosize () { return (0x7FFFFFFF/4) | 0;}\n\n//Provides: caml_sys_const_ostype_cygwin const\nfunction caml_sys_const_ostype_cygwin () { return 0; }\n//Provides: caml_sys_const_ostype_unix const\nfunction caml_sys_const_ostype_unix () { return 1; }\n//Provides: caml_sys_const_ostype_win32 const\nfunction caml_sys_const_ostype_win32 () { return 0; }\n\n//Provides: caml_sys_system_command\nfunction caml_sys_system_command(_cmd){\n return 127;\n}\n\n///////////// Array\n//Provides: caml_array_sub mutable\nfunction caml_array_sub (a, i, len) {\n var a2 = new Array(len+1);\n a2[0]=0;\n for(var i2 = 1, i1= i+1; i2 <= len; i2++,i1++ ){\n a2[i2]=a[i1];\n }\n return a2;\n}\n\n//Provides: caml_array_append mutable\nfunction caml_array_append(a1, a2) {\n var l1 = a1.length, l2 = a2.length;\n var l = l1+l2-1\n var a = new Array(l);\n a[0] = 0;\n var i = 1,j = 1;\n for(;i= 1; j--) a2[i2 + j] = a1[i1 + j];\n };\n return 0;\n}\n\n///////////// CamlinternalOO\n//Provides: caml_get_public_method const\nvar caml_method_cache = [];\nfunction caml_get_public_method (obj, tag, cacheid) {\n var meths = obj[1];\n var ofs = caml_method_cache[cacheid];\n if (ofs === null) {\n // Make sure the array is not sparse\n for (var i = caml_method_cache.length; i < cacheid; i++)\n caml_method_cache[i] = 0;\n } else if (meths[ofs] === tag) {\n// console.log(\"cache hit\");\n return meths[ofs - 1];\n }\n// console.log(\"cache miss\");\n var li = 3, hi = meths[1] * 2 + 1, mi;\n while (li < hi) {\n mi = ((li+hi) >> 1) | 1;\n if (tag < meths[mi+1]) hi = mi-2;\n else li = mi;\n }\n caml_method_cache[cacheid] = li + 1;\n /* return 0 if tag is not there */\n return (tag == meths[li+1] ? meths[li] : 0);\n}\n\n//Provides: caml_final_register const\nfunction caml_final_register () { return 0; }\n//Provides: caml_final_release const\nfunction caml_final_release () { return 0; }\n//Provides: caml_backtrace_status const\nfunction caml_backtrace_status () { return 0; }\n//Provides: caml_get_exception_backtrace const\nfunction caml_get_exception_backtrace () { return 0; }\n//Provides: caml_get_exception_raw_backtrace const\nfunction caml_get_exception_raw_backtrace () { return [0]; }\n//Provides: caml_record_backtrace\nfunction caml_record_backtrace () { return 0; }\n//Provides: caml_convert_raw_backtrace const\nfunction caml_convert_raw_backtrace () { return 0; }\n//Provides: caml_get_current_callstack const\nfunction caml_get_current_callstack () { return [0]; }\n//Provides: caml_sys_getenv (const)\n//Requires: caml_raise_not_found\n//Requires: caml_js_to_string\nfunction caml_sys_getenv (name) {\n var g = joo_global_object;\n var n = name.toString();\n //nodejs env\n if(g.process\n && g.process.env\n && g.process.env[n] != undefined)\n return caml_js_to_string(g.process.env[n]);\n caml_raise_not_found ();\n}\n//Provides: caml_sys_exit\n//Requires: caml_invalid_argument\nfunction caml_sys_exit (code) {\n var g = joo_global_object;\n if(g.quit) g.quit(code);\n //nodejs\n if(g.process && g.process.exit) g.process.exit(code);\n caml_invalid_argument(\"Function 'exit' not implemented\");\n}\n\n//Provides: caml_sys_get_argv const\n//Requires: caml_js_to_string\n//Requires: raw_array_sub\nfunction caml_sys_get_argv () {\n var g = joo_global_object;\n var main = \"a.out\";\n var args = []\n\n if(g.process\n && g.process.argv\n && g.process.argv.length > 0) {\n var argv = g.process.argv\n //nodejs\n main = argv[1];\n args = raw_array_sub(argv,2,argv.length - 2);\n }\n\n var p = caml_js_to_string(main);\n var args2 = [0, p];\n for(var i = 0; i < args.length; i++)\n args2.push(caml_js_to_string(args[i]));\n return [0, p, args2];\n}\n\n//Provides: unix_inet_addr_of_string\nfunction unix_inet_addr_of_string () {return 0;}\n\n//Provides: caml_oo_last_id\nvar caml_oo_last_id = 0;\n\n//Provides: caml_set_oo_id\n//Requires: caml_oo_last_id\nfunction caml_set_oo_id (b) {\n b[2]=caml_oo_last_id++;\n return b;\n}\n\n//Provides: caml_fresh_oo_id\n//Requires: caml_oo_last_id\nfunction caml_fresh_oo_id() {\n return caml_oo_last_id++;\n}\n\n//Provides: caml_install_signal_handler const\nfunction caml_install_signal_handler(){return 0}\n\n\n//Provides: caml_convert_raw_backtrace_slot\n//Requires: caml_failwith\nfunction caml_convert_raw_backtrace_slot(){\n caml_failwith(\"caml_convert_raw_backtrace_slot\");\n}\n\n//Provides: caml_bswap16\nfunction caml_bswap16(x) {\n return ((((x & 0x00FF) << 8) |\n ((x & 0xFF00) >> 8)));\n}\n//Provides: caml_int32_bswap\nfunction caml_int32_bswap(x) {\n return (((x & 0x000000FF) << 24) |\n ((x & 0x0000FF00) << 8) |\n ((x & 0x00FF0000) >> 8) |\n ((x & 0xFF000000) >> 24));\n}\n//Provides: caml_int64_bswap\nfunction caml_int64_bswap(x) {\n return [\n 255,\n (((x[3] & 0x0000ff00) >> 8) |\n ((x[3] & 0x000000ff) << 8) |\n ((x[2] & 0x00ff0000))),\n (((x[2] & 0x0000ff00) >> 8) |\n ((x[2] & 0x000000ff) << 8) |\n ((x[1] & 0x00ff0000))),\n (((x[1] & 0x0000ff00) >> 8) |\n ((x[1] & 0x000000ff) << 8))]\n}\n\n//Provides: caml_list_of_js_array const (const)\nfunction caml_list_of_js_array(a){\n var l = 0;\n for(var i=a.length - 1; i>=0; i--){\n var e = a[i];\n l = [0,e,l];\n }\n return l\n}\n\n//Provides: caml_runtime_warnings\nvar caml_runtime_warnings = 0;\n\n//Provides: caml_ml_enable_runtime_warnings\n//Requires: caml_runtime_warnings\nfunction caml_ml_enable_runtime_warnings (bool) {\n caml_runtime_warnings = bool;\n return 0;\n}\n\n//Provides: caml_ml_runtime_warnings_enabled\n//Requires: caml_runtime_warnings\nfunction caml_ml_runtime_warnings_enabled (_unit) {\n return caml_runtime_warnings;\n}\n\n\n//Provides: caml_sys_isatty\nfunction caml_sys_isatty(_chan) {\n return 0;\n}\n", "// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010-2014 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n// An OCaml string is an object with three fields:\n// - tag 't'\n// - length 'l'\n// - contents 'c'\n//\n// The contents of the string can be either a JavaScript array or\n// a JavaScript string. The length of this string can be less than the\n// length of the OCaml string. In this case, remaining bytes are\n// assumed to be zeroes. Arrays are mutable but consumes more memory\n// than strings. A common pattern is to start from an empty string and\n// progressively fill it from the start. Partial strings makes it\n// possible to implement this efficiently.\n//\n// When converting to and from UTF-16, we keep track of whether the\n// string is composed only of ASCII characters (in which case, no\n// conversion needs to be performed) or not.\n//\n// The string tag can thus take the following values:\n// full string BYTE | UNKNOWN: 0\n// BYTE | ASCII: 9\n// BYTE | NOT_ASCII: 8\n// string prefix PARTIAL: 2\n// array ARRAY: 4\n//\n// One can use bit masking to discriminate these different cases:\n// known_encoding(x) = x&8\n// is_ascii(x) = x&1\n// kind(x) = x&6\n\n//Provides: caml_str_repeat\nfunction caml_str_repeat(n, s) {\n if (s.repeat) return s.repeat(n); // ECMAscript 6 and Firefox 24+\n var r = \"\", l = 0;\n if (n == 0) return r;\n for(;;) {\n if (n & 1) r += s;\n n >>= 1;\n if (n == 0) return r;\n s += s;\n l++;\n if (l == 9) {\n s.slice(0,1); // flatten the string\n // then, the flattening of the whole string will be faster,\n // as it will be composed of larger pieces\n }\n }\n}\n\n//Provides: caml_subarray_to_string\n//Requires: raw_array_sub\nfunction caml_subarray_to_string (a, i, len) {\n var f = String.fromCharCode;\n if (i == 0 && len <= 4096 && len == a.length) return f.apply (null, a);\n var s = \"\";\n for (; 0 < len; i += 1024,len-=1024)\n s += f.apply (null, raw_array_sub(a,i, Math.min(len, 1024)));\n return s;\n}\n\n//Provides: caml_utf8_of_utf16\nfunction caml_utf8_of_utf16(s) {\n for (var b = \"\", t = b, c, d, i = 0, l = s.length; i < l; i++) {\n c = s.charCodeAt(i);\n if (c < 0x80) {\n for (var j = i + 1; (j < l) && (c = s.charCodeAt(j)) < 0x80; j++);\n if (j - i > 512) { t.substr(0, 1); b += t; t = \"\"; b += s.slice(i, j) }\n else t += s.slice(i, j);\n if (j == l) break;\n i = j;\n }\n if (c < 0x800) {\n t += String.fromCharCode(0xc0 | (c >> 6));\n t += String.fromCharCode(0x80 | (c & 0x3f));\n } else if (c < 0xd800 || c >= 0xdfff) {\n t += String.fromCharCode(0xe0 | (c >> 12),\n 0x80 | ((c >> 6) & 0x3f),\n 0x80 | (c & 0x3f));\n } else if (c >= 0xdbff || i + 1 == l ||\n (d = s.charCodeAt(i + 1)) < 0xdc00 || d > 0xdfff) {\n // Unmatched surrogate pair, replaced by \\ufffd (replacement character)\n t += \"\\xef\\xbf\\xbd\";\n } else {\n i++;\n c = (c << 10) + d - 0x35fdc00;\n t += String.fromCharCode(0xf0 | (c >> 18),\n 0x80 | ((c >> 12) & 0x3f),\n 0x80 | ((c >> 6) & 0x3f),\n 0x80 | (c & 0x3f));\n }\n if (t.length > 1024) {t.substr(0, 1); b += t; t = \"\";}\n }\n return b+t;\n}\n\n//Provides: caml_utf16_of_utf8\nfunction caml_utf16_of_utf8(s) {\n for (var b = \"\", t = \"\", c, c1, c2, v, i = 0, l = s.length; i < l; i++) {\n c1 = s.charCodeAt(i);\n if (c1 < 0x80) {\n for (var j = i + 1; (j < l) && (c1 = s.charCodeAt(j)) < 0x80; j++);\n if (j - i > 512) { t.substr(0, 1); b += t; t = \"\"; b += s.slice(i, j) }\n else t += s.slice(i, j);\n if (j == l) break;\n i = j;\n }\n v = 1;\n if ((++i < l) && (((c2 = s.charCodeAt(i)) & -64) == 128)) {\n c = c2 + (c1 << 6);\n if (c1 < 0xe0) {\n v = c - 0x3080;\n if (v < 0x80) v = 1;\n } else {\n v = 2;\n if ((++i < l) && (((c2 = s.charCodeAt(i)) & -64) == 128)) {\n c = c2 + (c << 6);\n if (c1 < 0xf0) {\n v = c - 0xe2080;\n if ((v < 0x800) || ((v >= 0xd7ff) && (v < 0xe000))) v = 2;\n } else {\n v = 3;\n if ((++i < l) && (((c2 = s.charCodeAt(i)) & -64) == 128) &&\n (c1 < 0xf5)) {\n v = c2 - 0x3c82080 + (c << 6);\n if (v < 0x10000 || v > 0x10ffff) v = 3;\n }\n }\n }\n }\n }\n if (v < 4) { // Invalid sequence\n i -= v;\n t += \"\\ufffd\";\n } else if (v > 0xffff)\n t += String.fromCharCode(0xd7c0 + (v >> 10), 0xdc00 + (v & 0x3FF))\n else\n t += String.fromCharCode(v);\n if (t.length > 1024) {t.substr(0, 1); b += t; t = \"\";}\n }\n return b+t;\n}\n\n//Provides: caml_is_ascii\nfunction caml_is_ascii (s) {\n // The regular expression gets better at around this point for all browsers\n if (s.length < 24) {\n // Spidermonkey gets much slower when s.length >= 24 (on 64 bit archs)\n for (var i = 0; i < s.length; i++) if (s.charCodeAt(i) > 127) return false;\n return true;\n } else\n return !/[^\\x00-\\x7f]/.test(s);\n}\n\n//Provides: caml_to_js_string\n//Requires: caml_convert_string_to_bytes, caml_is_ascii, caml_utf16_of_utf8\nfunction caml_to_js_string(s) {\n switch (s.t) {\n case 9: /*BYTES | ASCII*/\n return s.c;\n default:\n caml_convert_string_to_bytes(s);\n case 0: /*BYTES | UNKOWN*/\n if (caml_is_ascii(s.c)) {\n s.t = 9; /*BYTES | ASCII*/\n return s.c;\n }\n s.t = 8; /*BYTES | NOT_ASCII*/\n case 8: /*BYTES | NOT_ASCII*/\n return caml_utf16_of_utf8(s.c);\n }\n}\n\n//Provides: caml_string_unsafe_get mutable\nfunction caml_string_unsafe_get (s, i) {\n switch (s.t & 6) {\n default: /* PARTIAL */\n if (i >= s.c.length) return 0;\n case 0: /* BYTES */\n return s.c.charCodeAt(i);\n case 4: /* ARRAY */\n return s.c[i]\n }\n}\n\n//Provides: caml_string_unsafe_set\n//Requires: caml_convert_string_to_array\nfunction caml_string_unsafe_set (s, i, c) {\n // The OCaml compiler uses Char.unsafe_chr on integers larger than 255!\n c &= 0xff;\n if (s.t != 4 /* ARRAY */) {\n if (i == s.c.length) {\n s.c += String.fromCharCode (c);\n if (i + 1 == s.l) s.t = 0; /*BYTES | UNKOWN*/\n return 0;\n }\n caml_convert_string_to_array (s);\n }\n s.c[i] = c;\n return 0;\n}\n\n//Provides: caml_string_bound_error\n//Requires: caml_invalid_argument\nfunction caml_string_bound_error () {\n caml_invalid_argument (\"index out of bounds\");\n}\n\n//Provides: caml_string_get\n//Requires: caml_string_bound_error, caml_string_unsafe_get\nfunction caml_string_get (s, i) {\n if (i >>> 0 >= s.l) caml_string_bound_error();\n return caml_string_unsafe_get (s, i);\n}\n\n//Provides: caml_string_set\n//Requires: caml_string_bound_error, caml_string_unsafe_set\nfunction caml_string_set (s, i, c) {\n if (i >>> 0 >= s.l) caml_string_bound_error();\n return caml_string_unsafe_set (s, i, c);\n}\n\n//Provides: MlString\n//Requires: caml_to_js_string\nfunction MlString (tag, contents, length) {\n this.t=tag; this.c=contents; this.l=length;\n}\nMlString.prototype.toString = function(){return caml_to_js_string(this)};\n\n//Provides: caml_convert_string_to_bytes\n//Requires: caml_str_repeat, caml_subarray_to_string\nfunction caml_convert_string_to_bytes (s) {\n /* Assumes not BYTES */\n if (s.t == 2 /* PARTIAL */)\n s.c += caml_str_repeat(s.l - s.c.length, '\\0')\n else\n s.c = caml_subarray_to_string (s.c, 0, s.c.length);\n s.t = 0; /*BYTES | UNKOWN*/\n}\n\n//Provides: caml_convert_string_to_array\nfunction caml_convert_string_to_array (s) {\n /* Assumes not ARRAY */\n if(joo_global_object.Uint8Array) {\n var a = new joo_global_object.Uint8Array(s.l);\n } else {\n var a = new Array(s.l);\n }\n var b = s.c, l = b.length, i = 0;\n for (; i < l; i++) a[i] = b.charCodeAt(i);\n for (l = s.l; i < l; i++) a[i] = 0;\n s.c = a;\n s.t = 4; /* ARRAY */\n return a;\n}\n\n//Provides: caml_array_of_string mutable\n//Requires: caml_convert_string_to_array\nfunction caml_array_of_string (s) {\n if (s.t != 4 /* ARRAY */) caml_convert_string_to_array(s);\n return s.c;\n}\n\n//Provides: caml_bytes_of_string mutable\n//Requires: caml_convert_string_to_bytes\nfunction caml_bytes_of_string (s) {\n if ((s.t & 6) != 0 /* BYTES */) caml_convert_string_to_bytes(s);\n return s.c;\n}\n\n//Provides: caml_js_to_string const\n//Requires: caml_is_ascii, caml_utf8_of_utf16, MlString\nfunction caml_js_to_string (s) {\n var tag = 9 /* BYTES | ASCII */;\n if (!caml_is_ascii(s))\n tag = 8 /* BYTES | NOT_ASCII */, s = caml_utf8_of_utf16(s);\n return new MlString(tag, s, s.length);\n}\n\n//Provides: caml_create_string const\n//Requires: MlString,caml_invalid_argument\nfunction caml_create_string(len) {\n if (len < 0) caml_invalid_argument(\"String.create\");\n return new MlString(len?2:9,\"\",len);\n}\n//Provides: caml_new_string\n//Requires: MlString\nfunction caml_new_string (s) { return new MlString(0,s,s.length); }\n//Provides: caml_string_of_array\n//Requires: MlString\nfunction caml_string_of_array (a) { return new MlString(4,a,a.length); }\n\n//Provides: caml_string_compare mutable\n//Requires: caml_convert_string_to_bytes\nfunction caml_string_compare(s1, s2) {\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c < s2.c)?-1:(s1.c > s2.c)?1:0;\n}\n\n//Provides: caml_string_equal mutable (const, const)\n//Requires: caml_convert_string_to_bytes\nfunction caml_string_equal(s1, s2) {\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c == s2.c)?1:0;\n}\n\n//Provides: caml_string_notequal mutable (const, const)\n//Requires: caml_string_equal\nfunction caml_string_notequal(s1, s2) { return 1-caml_string_equal(s1, s2); }\n\n//Provides: caml_string_lessequal mutable\n//Requires: caml_convert_string_to_bytes\nfunction caml_string_lessequal(s1, s2) {\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c <= s2.c)?1:0;\n}\n\n//Provides: caml_string_lessthan mutable\n//Requires: caml_convert_string_to_bytes\nfunction caml_string_lessthan(s1, s2) {\n (s1.t & 6) && caml_convert_string_to_bytes(s1);\n (s2.t & 6) && caml_convert_string_to_bytes(s2);\n return (s1.c < s2.c)?1:0;\n}\n\n//Provides: caml_string_greaterequal\n//Requires: caml_string_lessequal\nfunction caml_string_greaterequal(s1, s2) {\n return caml_string_lessequal(s2,s1);\n}\n\n//Provides: caml_string_greaterthan\n//Requires: caml_string_lessthan\nfunction caml_string_greaterthan(s1, s2) {\n return caml_string_lessthan(s2, s1);\n}\n\n//Provides: caml_fill_string\n//Requires: caml_str_repeat, caml_convert_string_to_array\nfunction caml_fill_string(s, i, l, c) {\n if (l > 0) {\n if (i == 0 && (l >= s.l || (s.t == 2 /* PARTIAL */ && l >= s.c.length))) {\n if (c == 0) {\n s.c = \"\";\n s.t = 2; /* PARTIAL */\n } else {\n s.c = caml_str_repeat (l, String.fromCharCode(c));\n s.t = (l == s.l)?0 /* BYTES | UNKOWN */ :2; /* PARTIAL */\n }\n } else {\n if (s.t != 4 /* ARRAY */) caml_convert_string_to_array(s);\n for (l += i; i < l; i++) s.c[i] = c;\n }\n }\n return 0;\n}\n\n//Provides: caml_blit_string\n//Requires: caml_subarray_to_string, caml_convert_string_to_array\nfunction caml_blit_string(s1, i1, s2, i2, len) {\n if (len == 0) return 0;\n if ((i2 == 0) &&\n (len >= s2.l || (s2.t == 2 /* PARTIAL */ && len >= s2.c.length))) {\n s2.c = (s1.t == 4 /* ARRAY */)?\n caml_subarray_to_string(s1.c, i1, len):\n (i1 == 0 && s1.c.length == len)?s1.c:s1.c.substr(i1, len);\n s2.t = (s2.c.length == s2.l)?0 /* BYTES | UNKOWN */ :2; /* PARTIAL */\n } else if (s2.t == 2 /* PARTIAL */ && i2 == s2.c.length) {\n s2.c += (s1.t == 4 /* ARRAY */)?\n caml_subarray_to_string(s1.c, i1, len):\n (i1 == 0 && s1.c.length == len)?s1.c:s1.c.substr(i1, len);\n s2.t = (s2.c.length == s2.l)?0 /* BYTES | UNKOWN */ :2; /* PARTIAL */\n } else {\n if (s2.t != 4 /* ARRAY */) caml_convert_string_to_array(s2);\n var c1 = s1.c, c2 = s2.c;\n if (s1.t == 4 /* ARRAY */)\n for (var i = 0; i < len; i++) c2 [i2 + i] = c1 [i1 + i];\n else {\n var l = Math.min (len, c1.length - i1);\n for (var i = 0; i < l; i++) c2 [i2 + i] = c1.charCodeAt(i1 + i);\n for (; i < len; i++) c2 [i2 + i] = 0;\n }\n }\n return 0;\n}\n\n//Provides: caml_ml_string_length const\nfunction caml_ml_string_length(s) { return s.l }\n", "// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: jsoo_floor_log2\nvar log2_ok = Math.log2 && Math.log2(1.1235582092889474E+307) == 1020\nfunction jsoo_floor_log2(x) {\n if(log2_ok) return Math.floor(Math.log2(x))\n var i = 0;\n if (x == 0) return -Infinity;\n if(x>=1) {while (x>=2) {x/=2; i++} }\n else {while (x < 1) {x*=2; i--} };\n return i;\n}\n\n//Provides: caml_int64_bits_of_float const\n//Requires: jsoo_floor_log2\nfunction caml_int64_bits_of_float (x) {\n if (!isFinite(x)) {\n if (isNaN(x)) return [255, 1, 0, 0xfff0];\n return (x > 0)?[255,0,0,0x7ff0]:[255,0,0,0xfff0];\n }\n var sign = (x==0 && 1/x == -Infinity)?0x8000:(x>=0)?0:0x8000;\n if (sign) x = -x;\n // Int64.bits_of_float 1.1235582092889474E+307 = 0x7fb0000000000000L\n // using Math.LOG2E*Math.log(x) in place of Math.log2 result in precision lost\n var exp = jsoo_floor_log2(x) + 1023;\n if (exp <= 0) {\n exp = 0;\n x /= Math.pow(2,-1026);\n } else {\n x /= Math.pow(2,exp-1027);\n if (x < 16) {\n x *= 2; exp -=1; }\n if (exp == 0) {\n x /= 2; }\n }\n var k = Math.pow(2,24);\n var r3 = x|0;\n x = (x - r3) * k;\n var r2 = x|0;\n x = (x - r2) * k;\n var r1 = x|0;\n r3 = (r3 &0xf) | sign | exp << 4;\n return [255, r1, r2, r3];\n}\n\n//Provides: caml_int32_bits_of_float const\n//Requires: jsoo_floor_log2\nfunction caml_int32_bits_of_float (x) {\n var float32a = new joo_global_object.Float32Array(1);\n float32a[0] = x;\n var int32a = new joo_global_object.Int32Array(float32a.buffer);\n return int32a[0] | 0;\n}\n\n//FP literals can be written using the hexadecimal\n//notation 0xp from ISO C99.\n//https://github.com/dankogai/js-hexfloat/blob/master/hexfloat.js\n//Provides: caml_hexstring_of_float const\n//Requires: caml_js_to_string, caml_str_repeat\nfunction caml_hexstring_of_float (x, prec, style) {\n if (!isFinite(x)) {\n if (isNaN(x)) return caml_js_to_string(\"nan\");\n return caml_js_to_string ((x > 0)?\"infinity\":\"-infinity\");\n }\n var sign = (x==0 && 1/x == -Infinity)?1:(x>=0)?0:1;\n if(sign) x = -x;\n var exp = 0;\n if (x == 0) { }\n else if (x < 1) {\n while (x < 1 && exp > -1022) { x *= 2; exp-- }\n } else {\n while (x >= 2) { x /= 2; exp++ }\n }\n var exp_sign = exp < 0 ? '' : '+';\n var sign_str = '';\n if (sign) sign_str = '-'\n else {\n switch(style){\n case 43 /* '+' */: sign_str = '+'; break;\n case 32 /* ' ' */: sign_str = ' '; break;\n default: break;\n }\n }\n if (prec >= 0 && prec < 13) {\n /* If a precision is given, and is small, round mantissa accordingly */\n var cst = Math.pow(2,prec * 4);\n x = Math.round(x * cst) / cst;\n }\n var x_str = x.toString(16);\n if(prec >= 0){\n var idx = x_str.indexOf('.');\n if(idx<0) {\n x_str += '.' + caml_str_repeat(prec, '0');\n }\n else {\n var size = idx+1+prec;\n if(x_str.length < size)\n x_str += caml_str_repeat(size - x_str.length, '0');\n else\n x_str = x_str.substr(0,size);\n }\n }\n return caml_js_to_string (sign_str + '0x' + x_str + 'p' + exp_sign + exp.toString(10));\n}\n\n//Provides: caml_int64_float_of_bits const\nfunction caml_int64_float_of_bits (x) {\n var exp = (x[3] & 0x7fff) >> 4;\n if (exp == 2047) {\n if ((x[1]|x[2]|(x[3]&0xf)) == 0)\n return (x[3] & 0x8000)?(-Infinity):Infinity;\n else\n return NaN;\n }\n var k = Math.pow(2,-24);\n var res = (x[1]*k+x[2])*k+(x[3]&0xf);\n if (exp > 0) {\n res += 16;\n res *= Math.pow(2,exp-1027);\n } else\n res *= Math.pow(2,-1026);\n if (x[3] & 0x8000) res = - res;\n return res;\n}\n\n//Provides: caml_int32_float_of_bits const\nfunction caml_int32_float_of_bits (x) {\n var int32a = new joo_global_object.Int32Array(1);\n int32a[0] = x;\n var float32a = new joo_global_object.Float32Array(int32a.buffer);\n return float32a[0];\n}\n\n//Provides: caml_classify_float const\nfunction caml_classify_float (x) {\n if (isFinite (x)) {\n if (Math.abs(x) >= 2.2250738585072014e-308) return 0;\n if (x != 0) return 1;\n return 2;\n }\n return isNaN(x)?4:3;\n}\n//Provides: caml_modf_float const\nfunction caml_modf_float (x) {\n if (isFinite (x)) {\n var neg = (1/x) < 0;\n x = Math.abs(x);\n var i = Math.floor (x);\n var f = x - i;\n if (neg) { i = -i; f = -f; }\n return [0, f, i];\n }\n if (isNaN (x)) return [0, NaN, NaN];\n return [0, 1/x, x];\n}\n//Provides: caml_ldexp_float const\nfunction caml_ldexp_float (x,exp) {\n exp |= 0;\n if (exp > 1023) {\n exp -= 1023;\n x *= Math.pow(2, 1023);\n if (exp > 1023) { // in case x is subnormal\n exp -= 1023;\n x *= Math.pow(2, 1023);\n }\n }\n if (exp < -1023) {\n exp += 1023;\n x *= Math.pow(2, -1023);\n }\n x *= Math.pow(2, exp);\n return x;\n}\n//Provides: caml_frexp_float const\n//Requires: jsoo_floor_log2\nfunction caml_frexp_float (x) {\n if ((x == 0) || !isFinite(x)) return [0, x, 0];\n var neg = x < 0;\n if (neg) x = - x;\n var exp = jsoo_floor_log2(x) + 1;\n x *= Math.pow(2,-exp);\n if (x < 0.5) { x *= 2; exp -= 1; }\n if (neg) x = - x;\n return [0, x, exp];\n}\n\n//Provides: caml_float_compare const\nfunction caml_float_compare (x, y) {\n if (x === y) return 0;\n if (x < y) return -1;\n if (x > y) return 1;\n if (x === x) return 1;\n if (y === y) return -1;\n return 0;\n}\n\n//Provides: caml_copysign_float const\nfunction caml_copysign_float (x, y) {\n if (y == 0) y = 1 / y;\n x = Math.abs(x);\n return (y < 0)?(-x):x;\n}\n\n//Provides: caml_expm1_float const\nfunction caml_expm1_float (x) {\n var y = Math.exp(x), z = y - 1;\n return (Math.abs(x)>1?z:(z==0?x:x*z/Math.log(y)));\n}\n\n//Provides: caml_log1p_float const\nfunction caml_log1p_float (x) {\n var y = 1 + x, z = y - 1;\n return (z==0?x:x*Math.log(y)/z);\n}\n\n//Provides: caml_hypot_float const\nfunction caml_hypot_float (x, y) {\n var x = Math.abs(x), y = Math.abs(y);\n var a = Math.max(x, y), b = Math.min(x,y) / (a?a:1);\n return (a * Math.sqrt(1 + b*b));\n}\n\n// FIX: these five functions only give approximate results.\n//Provides: caml_log10_float const\nfunction caml_log10_float (x) { return Math.LOG10E * Math.log(x); }\n//Provides: caml_cosh_float const\nfunction caml_cosh_float (x) { return (Math.exp(x) + Math.exp(-x)) / 2; }\n//Provides: caml_sinh_float const\nfunction caml_sinh_float (x) { return (Math.exp(x) - Math.exp(-x)) / 2; }\n//Provides: caml_tanh_float const\nfunction caml_tanh_float (x) {\n var y = Math.exp(x), z = Math.exp(-x);\n return (y + z) / (y - z);\n}\n", "// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n//Provides: caml_int64_offset\nvar caml_int64_offset = Math.pow(2, -24);\n\n//Provides: caml_int64_ucompare const\nfunction caml_int64_ucompare(x,y) {\n if (x[3] > y[3]) return 1;\n if (x[3] < y[3]) return -1;\n if (x[2] > y[2]) return 1;\n if (x[2] < y[2]) return -1;\n if (x[1] > y[1]) return 1;\n if (x[1] < y[1]) return -1;\n return 0;\n}\n\n//Provides: caml_int64_ult const\n//Requires: caml_int64_ucompare\nfunction caml_int64_ult(x,y) { return caml_int64_ucompare(x,y) < 0; }\n\n//Provides: caml_int64_compare const\nfunction caml_int64_compare(x,y) {\n var x3 = x[3] << 16;\n var y3 = y[3] << 16;\n if (x3 > y3) return 1;\n if (x3 < y3) return -1;\n if (x[2] > y[2]) return 1;\n if (x[2] < y[2]) return -1;\n if (x[1] > y[1]) return 1;\n if (x[1] < y[1]) return -1;\n return 0;\n}\n\n//Provides: caml_int64_neg const\nfunction caml_int64_neg (x) {\n var y1 = - x[1];\n var y2 = - x[2] + (y1 >> 24);\n var y3 = - x[3] + (y2 >> 24);\n return [255, y1 & 0xffffff, y2 & 0xffffff, y3 & 0xffff];\n}\n\n//Provides: caml_int64_add const\nfunction caml_int64_add (x, y) {\n var z1 = x[1] + y[1];\n var z2 = x[2] + y[2] + (z1 >> 24);\n var z3 = x[3] + y[3] + (z2 >> 24);\n return [255, z1 & 0xffffff, z2 & 0xffffff, z3 & 0xffff];\n}\n\n//Provides: caml_int64_sub const\nfunction caml_int64_sub (x, y) {\n var z1 = x[1] - y[1];\n var z2 = x[2] - y[2] + (z1 >> 24);\n var z3 = x[3] - y[3] + (z2 >> 24);\n return [255, z1 & 0xffffff, z2 & 0xffffff, z3 & 0xffff];\n}\n\n//Provides: caml_int64_mul const\n//Requires: caml_int64_offset\nfunction caml_int64_mul(x,y) {\n var z1 = x[1] * y[1];\n var z2 = ((z1 * caml_int64_offset) | 0) + x[2] * y[1] + x[1] * y[2];\n var z3 = ((z2 * caml_int64_offset) | 0) + x[3] * y[1] + x[2] * y[2] + x[1] * y[3];\n return [255, z1 & 0xffffff, z2 & 0xffffff, z3 & 0xffff];\n}\n\n//Provides: caml_int64_is_zero const\nfunction caml_int64_is_zero(x) {\n return (x[3]|x[2]|x[1]) == 0;\n}\n\n//Provides: caml_int64_is_negative const\nfunction caml_int64_is_negative(x) {\n return (x[3] << 16) < 0;\n}\n\n//Provides: caml_int64_is_min_int const\nfunction caml_int64_is_min_int(x) {\n return x[3] == 0x8000 && (x[1]|x[2]) == 0;\n}\n\n//Provides: caml_int64_is_minus_one const\nfunction caml_int64_is_minus_one(x) {\n return x[3] == 0xffff && (x[1]&x[2]) == 0xffffff;\n}\n\n//Provides: caml_int64_and const\nfunction caml_int64_and (x, y) {\n return [255, x[1]&y[1], x[2]&y[2], x[3]&y[3]];\n}\n\n//Provides: caml_int64_or const\nfunction caml_int64_or (x, y) {\n return [255, x[1]|y[1], x[2]|y[2], x[3]|y[3]];\n}\n\n//Provides: caml_int64_xor const\nfunction caml_int64_xor (x, y) {\n return [255, x[1]^y[1], x[2]^y[2], x[3]^y[3]];\n}\n\n//Provides: caml_int64_shift_left const\nfunction caml_int64_shift_left (x, s) {\n s = s & 63;\n if (s == 0) return x;\n if (s < 24)\n return [255,\n (x[1] << s) & 0xffffff,\n ((x[2] << s) | (x[1] >> (24 - s))) & 0xffffff,\n ((x[3] << s) | (x[2] >> (24 - s))) & 0xffff];\n if (s < 48)\n return [255, 0,\n (x[1] << (s - 24)) & 0xffffff,\n ((x[2] << (s - 24)) | (x[1] >> (48 - s))) & 0xffff];\n return [255, 0, 0, (x[1] << (s - 48)) & 0xffff];\n}\n\n//Provides: caml_int64_shift_right_unsigned const\nfunction caml_int64_shift_right_unsigned (x, s) {\n s = s & 63;\n if (s == 0) return x;\n if (s < 24)\n return [255,\n ((x[1] >> s) | (x[2] << (24 - s))) & 0xffffff,\n ((x[2] >> s) | (x[3] << (24 - s))) & 0xffffff,\n (x[3] >> s)];\n if (s < 48)\n return [255,\n ((x[2] >> (s - 24)) | (x[3] << (48 - s))) & 0xffffff,\n (x[3] >> (s - 24)),\n 0];\n return [255, (x[3] >> (s - 48)), 0, 0];\n}\n\n//Provides: caml_int64_shift_right const\nfunction caml_int64_shift_right (x, s) {\n s = s & 63;\n if (s == 0) return x;\n var h = (x[3] << 16) >> 16;\n if (s < 24)\n return [255,\n ((x[1] >> s) | (x[2] << (24 - s))) & 0xffffff,\n ((x[2] >> s) | (h << (24 - s))) & 0xffffff,\n ((x[3] << 16) >> s) >>> 16];\n var sign = (x[3] << 16) >> 31;\n if (s < 48)\n return [255,\n ((x[2] >> (s - 24)) | (x[3] << (48 - s))) & 0xffffff,\n ((x[3] << 16) >> (s - 24) >> 16) & 0xffffff,\n sign & 0xffff];\n return [255,\n ((x[3] << 16) >> (s - 32)) & 0xffffff,\n sign & 0xffffff, sign & 0xffff];\n}\n\n//Provides: caml_int64_lsl1 const\nfunction caml_int64_lsl1 (x) {\n x[3] = (x[3] << 1) | (x[2] >> 23);\n x[2] = ((x[2] << 1) | (x[1] >> 23)) & 0xffffff;\n x[1] = (x[1] << 1) & 0xffffff;\n}\n\n//Provides: caml_int64_lsr1 const\nfunction caml_int64_lsr1 (x) {\n x[1] = ((x[1] >>> 1) | (x[2] << 23)) & 0xffffff;\n x[2] = ((x[2] >>> 1) | (x[3] << 23)) & 0xffffff;\n x[3] = x[3] >>> 1;\n}\n\n//Provides: caml_int64_udivmod const\n//Requires: caml_int64_ucompare, caml_int64_lsl1, caml_int64_lsr1\n//Requires: caml_int64_sub\n//Requires: caml_obj_dup\nfunction caml_int64_udivmod (x, y) {\n var offset = 0;\n var modulus = caml_obj_dup(x);\n var divisor = caml_obj_dup(y);\n var quotient = [255, 0, 0, 0];\n while (caml_int64_ucompare (modulus, divisor) > 0) {\n offset++;\n caml_int64_lsl1 (divisor);\n }\n while (offset >= 0) {\n offset --;\n caml_int64_lsl1 (quotient);\n if (caml_int64_ucompare (modulus, divisor) >= 0) {\n quotient[1] ++;\n modulus = caml_int64_sub (modulus, divisor);\n }\n caml_int64_lsr1 (divisor);\n }\n return [0,quotient, modulus];\n}\n\n//Provides: caml_int64_div const\n//Requires: caml_int64_is_zero, caml_raise_zero_divide\n//Requires: caml_int64_neg, caml_int64_udivmod\nfunction caml_int64_div (x, y)\n{\n if (caml_int64_is_zero (y)) caml_raise_zero_divide ();\n var sign = x[3] ^ y[3];\n if (x[3] & 0x8000) x = caml_int64_neg(x);\n if (y[3] & 0x8000) y = caml_int64_neg(y);\n var q = caml_int64_udivmod(x, y)[1];\n if (sign & 0x8000) q = caml_int64_neg(q);\n return q;\n}\n\n//Provides: caml_int64_mod const\n//Requires: caml_int64_is_zero, caml_raise_zero_divide\n//Requires: caml_int64_neg, caml_int64_udivmod\nfunction caml_int64_mod (x, y)\n{\n if (caml_int64_is_zero (y)) caml_raise_zero_divide ();\n var sign = x[3];\n if (x[3] & 0x8000) x = caml_int64_neg(x);\n if (y[3] & 0x8000) y = caml_int64_neg(y);\n var r = caml_int64_udivmod(x, y)[2];\n if (sign & 0x8000) r = caml_int64_neg(r);\n return r;\n}\n\n//Provides: caml_int64_of_int32 const\nfunction caml_int64_of_int32 (x) {\n return [255, x & 0xffffff, (x >> 24) & 0xffffff, (x >> 31) & 0xffff]\n}\n\n//Provides: caml_int64_to_int32 const\nfunction caml_int64_to_int32 (x) {\n return x[1] | (x[2] << 24);\n}\n\n//Provides: caml_int64_to_float const\nfunction caml_int64_to_float (x) {\n return ((x[3] << 16) * Math.pow(2, 32) + x[2] * Math.pow(2, 24)) + x[1];\n}\n\n//Provides: caml_int64_of_float const\n//Requires: caml_int64_offset\nfunction caml_int64_of_float (x) {\n if (x < 0) x = Math.ceil(x);\n return [255,\n x & 0xffffff,\n Math.floor(x * caml_int64_offset) & 0xffffff,\n Math.floor(x * caml_int64_offset * caml_int64_offset) & 0xffff];\n}\n\n//Provides: caml_int64_format const\n//Requires: caml_parse_format, caml_finish_formatting\n//Requires: caml_int64_is_negative, caml_int64_neg\n//Requires: caml_int64_of_int32, caml_int64_udivmod, caml_int64_to_int32\n//Requires: caml_int64_is_zero, caml_str_repeat\nfunction caml_int64_format (fmt, x) {\n var f = caml_parse_format(fmt);\n if (f.signedconv && caml_int64_is_negative(x)) {\n f.sign = -1; x = caml_int64_neg(x);\n }\n var buffer = \"\";\n var wbase = caml_int64_of_int32(f.base);\n var cvtbl = \"0123456789abcdef\";\n do {\n var p = caml_int64_udivmod(x, wbase);\n x = p[1];\n buffer = cvtbl.charAt(caml_int64_to_int32(p[2])) + buffer;\n } while (! caml_int64_is_zero(x));\n if (f.prec >= 0) {\n f.filler = ' ';\n var n = f.prec - buffer.length;\n if (n > 0) buffer = caml_str_repeat (n, '0') + buffer;\n }\n return caml_finish_formatting(f, buffer);\n}\n\n//Provides: caml_int64_of_string\n//Requires: caml_parse_sign_and_base, caml_failwith, caml_parse_digit, MlString\n//Requires: caml_int64_of_int32, caml_int64_udivmod, caml_int64_ult\n//Requires: caml_int64_add, caml_int64_mul, caml_int64_neg\n//Requires: caml_ml_string_length,caml_string_unsafe_get\nfunction caml_int64_of_string(s) {\n var r = caml_parse_sign_and_base (s);\n var i = r[0], sign = r[1], base = r[2];\n var base64 = caml_int64_of_int32(base);\n var threshold =\n caml_int64_udivmod([255, 0xffffff, 0xfffffff, 0xffff], base64)[1];\n var c = caml_string_unsafe_get(s, i);\n var d = caml_parse_digit(c);\n if (d < 0 || d >= base) caml_failwith(\"int_of_string\");\n var res = caml_int64_of_int32(d);\n for (;;) {\n i++;\n c = caml_string_unsafe_get(s, i);\n if (c == 95) continue;\n d = caml_parse_digit(c);\n if (d < 0 || d >= base) break;\n /* Detect overflow in multiplication base * res */\n if (caml_int64_ult(threshold, res)) caml_failwith(\"int_of_string\");\n d = caml_int64_of_int32(d);\n res = caml_int64_add(caml_int64_mul(base64, res), d);\n /* Detect overflow in addition (base * res) + d */\n if (caml_int64_ult(res, d)) caml_failwith(\"int_of_string\");\n }\n if (i != caml_ml_string_length(s)) caml_failwith(\"int_of_string\");\n if (r[2] == 10 && caml_int64_ult([255, 0, 0, 0x8000], res))\n caml_failwith(\"int_of_string\");\n if (sign < 0) res = caml_int64_neg(res);\n return res;\n}\n\n//Provides: caml_int64_of_bytes\nfunction caml_int64_of_bytes(a) {\n return [255, a[7] | (a[6] << 8) | (a[5] << 16),\n a[4] | (a[3] << 8) | (a[2] << 16), a[1] | (a[0] << 8)];\n}\n//Provides: caml_int64_to_bytes\nfunction caml_int64_to_bytes(x) {\n return [x[3] >> 8, x[3] & 0xff, x[2] >> 16, (x[2] >> 8) & 0xff, x[2] & 0xff,\n x[1] >> 16, (x[1] >> 8) & 0xff, x[1] & 0xff];\n}\n", "// Js_of_ocaml library\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Jslib: code specific to Js_of_ocaml\n\n//Provides: caml_js_from_bool const (const)\nfunction caml_js_from_bool(x) { return !!x; }\n//Provides: caml_js_to_bool const (const)\nfunction caml_js_to_bool(x) { return +x; }\n//Provides: caml_js_from_float const (const)\nfunction caml_js_from_float(x) { return x; }\n//Provides: caml_js_to_float const (const)\nfunction caml_js_to_float(x) { return x; }\n//Provides: caml_js_from_string mutable (const)\n//Requires: MlString\nfunction caml_js_from_string(s) { return s.toString(); }\n//Provides: caml_js_from_array mutable (shallow)\n//Requires: raw_array_sub\nfunction caml_js_from_array(a) { return raw_array_sub(a,1,a.length-1); }\n//Provides: caml_js_to_array mutable (shallow)\n//Requires: raw_array_cons\nfunction caml_js_to_array(a) { return raw_array_cons(a,0); }\n\n//Provides: caml_js_var mutable (const)\n//Requires: js_print_stderr\n//Requires: MlString\nfunction caml_js_var(x) {\n var x = x.toString();\n //Checks that x has the form ident[.ident]*\n if(!x.match(/^[a-zA-Z_$][a-zA-Z_$0-9]*(\\.[a-zA-Z_$][a-zA-Z_$0-9]*)*$/)){\n js_print_stderr(\"caml_js_var: \\\"\" + x + \"\\\" is not a valid JavaScript variable. continuing ..\");\n //joo_global_object.console.error(\"Js.Unsafe.eval_string\")\n }\n return eval(x);\n}\n//Provides: caml_js_call (const, mutable, shallow)\n//Requires: caml_js_from_array\nfunction caml_js_call(f, o, args) { return f.apply(o, caml_js_from_array(args)); }\n//Provides: caml_js_fun_call (const, shallow)\n//Requires: caml_js_from_array\nfunction caml_js_fun_call(f, args) { return f.apply(null, caml_js_from_array(args)); }\n//Provides: caml_js_meth_call (mutable, const, shallow)\n//Requires: MlString\n//Requires: caml_js_from_array\nfunction caml_js_meth_call(o, f, args) {\n return o[f.toString()].apply(o, caml_js_from_array(args));\n}\n//Provides: caml_js_new (const, shallow)\n//Requires: caml_js_from_array\nfunction caml_js_new(c, a) {\n switch (a.length) {\n case 1: return new c;\n case 2: return new c (a[1]);\n case 3: return new c (a[1],a[2]);\n case 4: return new c (a[1],a[2],a[3]);\n case 5: return new c (a[1],a[2],a[3],a[4]);\n case 6: return new c (a[1],a[2],a[3],a[4],a[5]);\n case 7: return new c (a[1],a[2],a[3],a[4],a[5],a[6]);\n case 8: return new c (a[1],a[2],a[3],a[4],a[5],a[6], a[7]);\n }\n function F() { return c.apply(this, caml_js_from_array(a)); }\n F.prototype = c.prototype;\n return new F;\n}\n//Provides: caml_js_wrap_callback const (const)\n//Requires: caml_call_gen,raw_array_copy\nfunction caml_js_wrap_callback(f) {\n return function () {\n if(arguments.length > 0){\n return caml_call_gen(f, raw_array_copy(arguments));\n } else {\n return caml_call_gen(f, [undefined]);\n }\n }\n}\n//Provides: caml_js_wrap_meth_callback const (const)\n//Requires: caml_call_gen,raw_array_cons\nfunction caml_js_wrap_meth_callback(f) {\n return function () {\n return caml_call_gen(f,raw_array_cons(arguments,this));\n }\n}\n//Provides: caml_js_wrap_meth_callback_unsafe const (const)\n//Requires: caml_call_gen,raw_array_cons\nfunction caml_js_wrap_meth_callback_unsafe(f) {\n return function () { f.apply(null, raw_array_cons(arguments,this)); }\n}\n//Provides: caml_js_equals mutable (const, const)\nfunction caml_js_equals (x, y) { return +(x == y); }\n//Provides: caml_js_to_byte_string const\n//Requires: caml_new_string\nfunction caml_js_to_byte_string (s) {return caml_new_string (s);}\n\n//Provides: caml_js_eval_string (const)\n//Requires: MlString\nfunction caml_js_eval_string (s) {return eval(s.toString());}\n\n//Provides: caml_js_expr (const)\n//Requires: js_print_stderr\n//Requires: MlString\nfunction caml_js_expr(s) {\n js_print_stderr(\"caml_js_expr: fallback to runtime evaluation\");\n return eval(s.toString());}\n\n//Provides: caml_pure_js_expr const (const)\n//Requires: js_print_stderr\n//Requires: MlString\nfunction caml_pure_js_expr (s){\n js_print_stderr(\"caml_pure_js_expr: fallback to runtime evaluation\");\n return eval(s.toString());}\n\n//Provides: caml_js_object (object_literal)\n//Requires: MlString\nfunction caml_js_object (a) {\n var o = {};\n for (var i = 1; i < a.length; i++) {\n var p = a[i];\n o[p[1].toString()] = p[2];\n }\n return o;\n}\n", "/***********************************************************************/\n/* */\n/* Objective Caml */\n/* */\n/* Xavier Leroy, projet Cristal, INRIA Rocquencourt */\n/* */\n/* Copyright 1996 Institut National de Recherche en Informatique et */\n/* en Automatique. All rights reserved. This file is distributed */\n/* under the terms of the GNU Library General Public License, with */\n/* the special exception on linking described in file ../LICENSE. */\n/* */\n/***********************************************************************/\n\n/* $Id: lexing.c 6045 2004-01-01 16:42:43Z doligez $ */\n\n/* The table-driven automaton for lexers generated by camllex. */\n\n//Provides: caml_lex_array\n//Requires: caml_bytes_of_string\nfunction caml_lex_array(s) {\n s = caml_bytes_of_string(s);\n var l = s.length / 2;\n var a = new Array(l);\n for (var i = 0; i < l; i++)\n a[i] = (s.charCodeAt(2 * i) | (s.charCodeAt(2 * i + 1) << 8)) << 16 >> 16;\n return a;\n}\n\n//Provides: caml_lex_engine\n//Requires: caml_failwith, caml_lex_array, caml_array_of_string\nfunction caml_lex_engine(tbl, start_state, lexbuf) {\n var lex_buffer = 2;\n var lex_buffer_len = 3;\n var lex_start_pos = 5;\n var lex_curr_pos = 6;\n var lex_last_pos = 7;\n var lex_last_action = 8;\n var lex_eof_reached = 9;\n var lex_base = 1;\n var lex_backtrk = 2;\n var lex_default = 3;\n var lex_trans = 4;\n var lex_check = 5;\n\n if (!tbl.lex_default) {\n tbl.lex_base = caml_lex_array (tbl[lex_base]);\n tbl.lex_backtrk = caml_lex_array (tbl[lex_backtrk]);\n tbl.lex_check = caml_lex_array (tbl[lex_check]);\n tbl.lex_trans = caml_lex_array (tbl[lex_trans]);\n tbl.lex_default = caml_lex_array (tbl[lex_default]);\n }\n\n var c, state = start_state;\n\n var buffer = caml_array_of_string(lexbuf[lex_buffer]);\n\n if (state >= 0) {\n /* First entry */\n lexbuf[lex_last_pos] = lexbuf[lex_start_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = -1;\n } else {\n /* Reentry after refill */\n state = -state - 1;\n }\n for(;;) {\n /* Lookup base address or action number for current state */\n var base = tbl.lex_base[state];\n if (base < 0) return -base-1;\n /* See if it's a backtrack point */\n var backtrk = tbl.lex_backtrk[state];\n if (backtrk >= 0) {\n lexbuf[lex_last_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = backtrk;\n }\n /* See if we need a refill */\n if (lexbuf[lex_curr_pos] >= lexbuf[lex_buffer_len]){\n if (lexbuf[lex_eof_reached] == 0)\n return -state - 1;\n else\n c = 256;\n }else{\n /* Read next input char */\n c = buffer[lexbuf[lex_curr_pos]];\n lexbuf[lex_curr_pos] ++;\n }\n /* Determine next state */\n if (tbl.lex_check[base + c] == state)\n state = tbl.lex_trans[base + c];\n else\n state = tbl.lex_default[state];\n /* If no transition on this char, return to last backtrack point */\n if (state < 0) {\n lexbuf[lex_curr_pos] = lexbuf[lex_last_pos];\n if (lexbuf[lex_last_action] == -1)\n caml_failwith(\"lexing: empty token\");\n else\n return lexbuf[lex_last_action];\n }else{\n /* Erase the EOF condition only if the EOF pseudo-character was\n consumed by the automaton (i.e. there was no backtrack above)\n */\n if (c == 256) lexbuf[lex_eof_reached] = 0;\n }\n }\n}\n\n/***********************************************/\n/* New lexer engine, with memory of positions */\n/***********************************************/\n\n//Provides: caml_new_lex_engine\n//Requires: caml_failwith, caml_lex_array\n//Requires: caml_bytes_of_string, caml_array_of_string\nfunction caml_lex_run_mem(s, i, mem, curr_pos) {\n for (;;) {\n var dst = s.charCodeAt(i); i++;\n if (dst == 0xff) return;\n var src = s.charCodeAt(i); i++;\n if (src == 0xff)\n mem [dst + 1] = curr_pos;\n else\n mem [dst + 1] = mem [src + 1];\n }\n}\n\nfunction caml_lex_run_tag(s, i, mem) {\n for (;;) {\n var dst = s.charCodeAt(i); i++;\n if (dst == 0xff) return ;\n var src = s.charCodeAt(i); i++;\n if (src == 0xff)\n mem [dst + 1] = -1;\n else\n mem [dst + 1] = mem [src + 1];\n }\n}\n\nfunction caml_new_lex_engine(tbl, start_state, lexbuf) {\n var lex_buffer = 2;\n var lex_buffer_len = 3;\n var lex_start_pos = 5;\n var lex_curr_pos = 6;\n var lex_last_pos = 7;\n var lex_last_action = 8;\n var lex_eof_reached = 9;\n var lex_mem = 10;\n var lex_base = 1;\n var lex_backtrk = 2;\n var lex_default = 3;\n var lex_trans = 4;\n var lex_check = 5;\n var lex_base_code = 6;\n var lex_backtrk_code = 7;\n var lex_default_code = 8;\n var lex_trans_code = 9;\n var lex_check_code = 10;\n var lex_code = 11;\n\n if (!tbl.lex_default) {\n tbl.lex_base = caml_lex_array (tbl[lex_base]);\n tbl.lex_backtrk = caml_lex_array (tbl[lex_backtrk]);\n tbl.lex_check = caml_lex_array (tbl[lex_check]);\n tbl.lex_trans = caml_lex_array (tbl[lex_trans]);\n tbl.lex_default = caml_lex_array (tbl[lex_default]);\n }\n if (!tbl.lex_default_code) {\n tbl.lex_base_code = caml_lex_array (tbl[lex_base_code]);\n tbl.lex_backtrk_code = caml_lex_array (tbl[lex_backtrk_code]);\n tbl.lex_check_code = caml_lex_array (tbl[lex_check_code]);\n tbl.lex_trans_code = caml_lex_array (tbl[lex_trans_code]);\n tbl.lex_default_code = caml_lex_array (tbl[lex_default_code]);\n }\n if (tbl.lex_code == null) tbl.lex_code = caml_bytes_of_string(tbl[lex_code]);\n\n var c, state = start_state;\n\n var buffer = caml_array_of_string(lexbuf[lex_buffer]);\n\n if (state >= 0) {\n /* First entry */\n lexbuf[lex_last_pos] = lexbuf[lex_start_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = -1;\n } else {\n /* Reentry after refill */\n state = -state - 1;\n }\n for(;;) {\n /* Lookup base address or action number for current state */\n var base = tbl.lex_base[state];\n if (base < 0) {\n var pc_off = tbl.lex_base_code[state];\n caml_lex_run_tag(tbl.lex_code, pc_off, lexbuf[lex_mem]);\n return -base-1;\n }\n /* See if it's a backtrack point */\n var backtrk = tbl.lex_backtrk[state];\n if (backtrk >= 0) {\n var pc_off = tbl.lex_backtrk_code[state];\n caml_lex_run_tag(tbl.lex_code, pc_off, lexbuf[lex_mem]);\n lexbuf[lex_last_pos] = lexbuf[lex_curr_pos];\n lexbuf[lex_last_action] = backtrk;\n }\n /* See if we need a refill */\n if (lexbuf[lex_curr_pos] >= lexbuf[lex_buffer_len]){\n if (lexbuf[lex_eof_reached] == 0)\n return -state - 1;\n else\n c = 256;\n }else{\n /* Read next input char */\n c = buffer[lexbuf[lex_curr_pos]];\n lexbuf[lex_curr_pos] ++;\n }\n /* Determine next state */\n var pstate = state ;\n if (tbl.lex_check[base + c] == state)\n state = tbl.lex_trans[base + c];\n else\n state = tbl.lex_default[state];\n /* If no transition on this char, return to last backtrack point */\n if (state < 0) {\n lexbuf[lex_curr_pos] = lexbuf[lex_last_pos];\n if (lexbuf[lex_last_action] == -1)\n caml_failwith(\"lexing: empty token\");\n else\n return lexbuf[lex_last_action];\n }else{\n /* If some transition, get and perform memory moves */\n var base_code = tbl.lex_base_code[pstate], pc_off;\n if (tbl.lex_check_code[base_code + c] == pstate)\n pc_off = tbl.lex_trans_code[base_code + c];\n else\n pc_off = tbl.lex_default_code[pstate];\n if (pc_off > 0)\n caml_lex_run_mem\n (tbl.lex_code, pc_off, lexbuf[lex_mem], lexbuf[lex_curr_pos]);\n /* Erase the EOF condition only if the EOF pseudo-character was\n consumed by the automaton (i.e. there was no backtrack above)\n */\n if (c == 256) lexbuf[lex_eof_reached] = 0;\n }\n }\n}\n\n", "// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2010 Jérôme Vouillon\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n\n//Provides: caml_md5_chan\n//Requires: caml_md5_string, caml_string_of_array,caml_ml_string_length\nfunction caml_md5_chan(chan,len){\n if(len<0){\n len=caml_ml_string_length(chan.file.data) - chan.offset;\n }\n return caml_md5_string(chan.file.data,chan.offset,len);\n}\n\n//Provides: caml_md5_string\n//Requires: caml_string_of_array, caml_convert_string_to_bytes\nvar caml_md5_string =\nfunction () {\n function add (x, y) { return (x + y) | 0; }\n function xx(q,a,b,x,s,t) {\n a = add(add(a, q), add(x, t));\n return add((a << s) | (a >>> (32 - s)), b);\n }\n function ff(a,b,c,d,x,s,t) {\n return xx((b & c) | ((~b) & d), a, b, x, s, t);\n }\n function gg(a,b,c,d,x,s,t) {\n return xx((b & d) | (c & (~d)), a, b, x, s, t);\n }\n function hh(a,b,c,d,x,s,t) { return xx(b ^ c ^ d, a, b, x, s, t); }\n function ii(a,b,c,d,x,s,t) { return xx(c ^ (b | (~d)), a, b, x, s, t); }\n\n function md5(buffer, length) {\n var i = length;\n buffer[i >> 2] |= 0x80 << (8 * (i & 3));\n for (i = (i & ~0x3) + 8;(i & 0x3F) < 60 ;i += 4)\n buffer[(i >> 2) - 1] = 0;\n buffer[(i >> 2) -1] = length << 3;\n buffer[i >> 2] = (length >> 29) & 0x1FFFFFFF;\n\n var w = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476];\n\n for(i = 0; i < buffer.length; i += 16) {\n var a = w[0], b = w[1], c = w[2], d = w[3];\n\n a = ff(a, b, c, d, buffer[i+ 0], 7, 0xD76AA478);\n d = ff(d, a, b, c, buffer[i+ 1], 12, 0xE8C7B756);\n c = ff(c, d, a, b, buffer[i+ 2], 17, 0x242070DB);\n b = ff(b, c, d, a, buffer[i+ 3], 22, 0xC1BDCEEE);\n a = ff(a, b, c, d, buffer[i+ 4], 7, 0xF57C0FAF);\n d = ff(d, a, b, c, buffer[i+ 5], 12, 0x4787C62A);\n c = ff(c, d, a, b, buffer[i+ 6], 17, 0xA8304613);\n b = ff(b, c, d, a, buffer[i+ 7], 22, 0xFD469501);\n a = ff(a, b, c, d, buffer[i+ 8], 7, 0x698098D8);\n d = ff(d, a, b, c, buffer[i+ 9], 12, 0x8B44F7AF);\n c = ff(c, d, a, b, buffer[i+10], 17, 0xFFFF5BB1);\n b = ff(b, c, d, a, buffer[i+11], 22, 0x895CD7BE);\n a = ff(a, b, c, d, buffer[i+12], 7, 0x6B901122);\n d = ff(d, a, b, c, buffer[i+13], 12, 0xFD987193);\n c = ff(c, d, a, b, buffer[i+14], 17, 0xA679438E);\n b = ff(b, c, d, a, buffer[i+15], 22, 0x49B40821);\n\n a = gg(a, b, c, d, buffer[i+ 1], 5, 0xF61E2562);\n d = gg(d, a, b, c, buffer[i+ 6], 9, 0xC040B340);\n c = gg(c, d, a, b, buffer[i+11], 14, 0x265E5A51);\n b = gg(b, c, d, a, buffer[i+ 0], 20, 0xE9B6C7AA);\n a = gg(a, b, c, d, buffer[i+ 5], 5, 0xD62F105D);\n d = gg(d, a, b, c, buffer[i+10], 9, 0x02441453);\n c = gg(c, d, a, b, buffer[i+15], 14, 0xD8A1E681);\n b = gg(b, c, d, a, buffer[i+ 4], 20, 0xE7D3FBC8);\n a = gg(a, b, c, d, buffer[i+ 9], 5, 0x21E1CDE6);\n d = gg(d, a, b, c, buffer[i+14], 9, 0xC33707D6);\n c = gg(c, d, a, b, buffer[i+ 3], 14, 0xF4D50D87);\n b = gg(b, c, d, a, buffer[i+ 8], 20, 0x455A14ED);\n a = gg(a, b, c, d, buffer[i+13], 5, 0xA9E3E905);\n d = gg(d, a, b, c, buffer[i+ 2], 9, 0xFCEFA3F8);\n c = gg(c, d, a, b, buffer[i+ 7], 14, 0x676F02D9);\n b = gg(b, c, d, a, buffer[i+12], 20, 0x8D2A4C8A);\n\n a = hh(a, b, c, d, buffer[i+ 5], 4, 0xFFFA3942);\n d = hh(d, a, b, c, buffer[i+ 8], 11, 0x8771F681);\n c = hh(c, d, a, b, buffer[i+11], 16, 0x6D9D6122);\n b = hh(b, c, d, a, buffer[i+14], 23, 0xFDE5380C);\n a = hh(a, b, c, d, buffer[i+ 1], 4, 0xA4BEEA44);\n d = hh(d, a, b, c, buffer[i+ 4], 11, 0x4BDECFA9);\n c = hh(c, d, a, b, buffer[i+ 7], 16, 0xF6BB4B60);\n b = hh(b, c, d, a, buffer[i+10], 23, 0xBEBFBC70);\n a = hh(a, b, c, d, buffer[i+13], 4, 0x289B7EC6);\n d = hh(d, a, b, c, buffer[i+ 0], 11, 0xEAA127FA);\n c = hh(c, d, a, b, buffer[i+ 3], 16, 0xD4EF3085);\n b = hh(b, c, d, a, buffer[i+ 6], 23, 0x04881D05);\n a = hh(a, b, c, d, buffer[i+ 9], 4, 0xD9D4D039);\n d = hh(d, a, b, c, buffer[i+12], 11, 0xE6DB99E5);\n c = hh(c, d, a, b, buffer[i+15], 16, 0x1FA27CF8);\n b = hh(b, c, d, a, buffer[i+ 2], 23, 0xC4AC5665);\n\n a = ii(a, b, c, d, buffer[i+ 0], 6, 0xF4292244);\n d = ii(d, a, b, c, buffer[i+ 7], 10, 0x432AFF97);\n c = ii(c, d, a, b, buffer[i+14], 15, 0xAB9423A7);\n b = ii(b, c, d, a, buffer[i+ 5], 21, 0xFC93A039);\n a = ii(a, b, c, d, buffer[i+12], 6, 0x655B59C3);\n d = ii(d, a, b, c, buffer[i+ 3], 10, 0x8F0CCC92);\n c = ii(c, d, a, b, buffer[i+10], 15, 0xFFEFF47D);\n b = ii(b, c, d, a, buffer[i+ 1], 21, 0x85845DD1);\n a = ii(a, b, c, d, buffer[i+ 8], 6, 0x6FA87E4F);\n d = ii(d, a, b, c, buffer[i+15], 10, 0xFE2CE6E0);\n c = ii(c, d, a, b, buffer[i+ 6], 15, 0xA3014314);\n b = ii(b, c, d, a, buffer[i+13], 21, 0x4E0811A1);\n a = ii(a, b, c, d, buffer[i+ 4], 6, 0xF7537E82);\n d = ii(d, a, b, c, buffer[i+11], 10, 0xBD3AF235);\n c = ii(c, d, a, b, buffer[i+ 2], 15, 0x2AD7D2BB);\n b = ii(b, c, d, a, buffer[i+ 9], 21, 0xEB86D391);\n\n w[0] = add(a, w[0]);\n w[1] = add(b, w[1]);\n w[2] = add(c, w[2]);\n w[3] = add(d, w[3]);\n }\n\n var t = new Array(16);\n for (var i = 0; i < 4; i++)\n for (var j = 0; j < 4; j++)\n t[i * 4 + j] = (w[i] >> (8 * j)) & 0xFF;\n return t;\n }\n\n return function (s, ofs, len) {\n // FIX: maybe we should perform the computation by chunk of 64 bytes\n // as in http://www.myersdaily.org/joseph/javascript/md5.js\n var buf = [];\n switch (s.t & 6) {\n default:\n caml_convert_string_to_bytes(s);\n case 0: /* BYTES */\n var b = s.c;\n for (var i = 0; i < len; i+=4) {\n var j = i + ofs;\n buf[i>>2] =\n b.charCodeAt(j) | (b.charCodeAt(j+1) << 8) |\n (b.charCodeAt(j+2) << 16) | (b.charCodeAt(j+3) << 24);\n }\n for (; i < len; i++) buf[i>>2] |= b.charCodeAt(i + ofs) << (8 * (i & 3));\n break;\n case 4: /* ARRAY */\n var a = s.c;\n for (var i = 0; i < len; i+=4) {\n var j = i + ofs;\n buf[i>>2] = a[j] | (a[j+1] << 8) | (a[j+2] << 16) | (a[j+3] << 24);\n }\n for (; i < len; i++) buf[i>>2] |= a[i + ofs] << (8 * (i & 3));\n }\n return caml_string_of_array(md5(buf, len));\n }\n} ();\n", "// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Io\n\n//Provides: caml_sys_close\n//Requires: caml_global_data\nfunction caml_sys_close(fd) {\n delete caml_global_data.fds[fd];\n return 0;\n}\n\n//Provides: caml_sys_open\n//Requires: MlString, caml_raise_sys_error, caml_global_data,caml_sys_file_exists\n//Requires: caml_fs_register,caml_make_path,caml_fs_content\n//Requires: caml_raise_no_such_file,caml_sys_is_directory\n//Requires: caml_create_string,MlFile,caml_ml_string_length\nfunction caml_sys_open_internal(idx,file,flags) {\n if(caml_global_data.fds === undefined) caml_global_data.fds = new Array();\n flags=flags?flags:{};\n var info = {};\n info.file = file;\n info.offset = flags.append?caml_ml_string_length(file.data):0;\n info.flags = flags;\n caml_global_data.fds[idx] = info;\n caml_global_data.fd_last_idx = idx;\n return idx;\n}\nfunction caml_sys_open (name, flags, _perms) {\n var f = {};\n while(flags){\n switch(flags[1]){\n case 0: f.rdonly = 1;break;\n case 1: f.wronly = 1;break;\n case 2: f.append = 1;break;\n case 3: f.create = 1;break;\n case 4: f.truncate = 1;break;\n case 5: f.excl = 1; break;\n case 6: f.binary = 1;break;\n case 7: f.text = 1;break;\n case 8: f.nonblock = 1;break;\n }\n flags=flags[2];\n }\n var name2 = name.toString();\n var path = caml_make_path(name);\n if(f.rdonly && f.wronly)\n caml_raise_sys_error(name2 + \" : flags Open_rdonly and Open_wronly are not compatible\");\n if(f.text && f.binary)\n caml_raise_sys_error(name2 + \" : flags Open_text and Open_binary are not compatible\");\n if (caml_sys_file_exists(name)) {\n if (caml_sys_is_directory(name)) caml_raise_sys_error(name2 + \" : is a directory\");\n if (f.create && f.excl) caml_raise_sys_error(name2 + \" : file already exists\");\n var idx = caml_global_data.fd_last_idx?caml_global_data.fd_last_idx:0;\n var file = caml_fs_content(path);\n if(f.truncate) file.truncate();\n return caml_sys_open_internal (idx+1,file,f);\n } else if (f.create) {\n var idx = caml_global_data.fd_last_idx?caml_global_data.fd_last_idx:0;\n caml_fs_register(name,caml_create_string(0));\n var file = caml_fs_content(path);\n return caml_sys_open_internal (idx+1,file,f);\n }\n else caml_raise_no_such_file (name);\n}\ncaml_sys_open_internal(0,new MlFile(caml_create_string(0))); //stdin\ncaml_sys_open_internal(1,new MlFile(caml_create_string(0))); //stdout\ncaml_sys_open_internal(2,new MlFile(caml_create_string(0))); //stderr\n\n\n// ocaml Channels\n\n//Provides: caml_ml_set_channel_name\nfunction caml_ml_set_channel_name() {\n return 0\n}\n\n//Provides: caml_ml_out_channels\nvar caml_ml_out_channels = new Array();\n\n//Provides: caml_ml_out_channels_list\n//Requires: caml_ml_out_channels\nfunction caml_ml_out_channels_list () {\n var l = 0;\n for(var c in caml_ml_out_channels){\n if(caml_ml_out_channels[c].opened)\n l=[0,caml_ml_out_channels[c],l];\n }\n return l;\n}\n\n\n//Provides: caml_ml_open_descriptor_out\n//Requires: js_print_stderr, js_print_stdout, caml_ml_out_channels, caml_global_data,caml_sys_open\n//Requires: caml_raise_sys_error,caml_new_string\n//Requires: caml_create_string, caml_blit_string,caml_ml_string_length\nfunction caml_std_output(chan,s){\n var str = caml_new_string(s);\n var slen = caml_ml_string_length(str);\n var clen = caml_ml_string_length(chan.file.data);\n var offset = chan.offset;\n if(offset + slen >= clen) {\n var new_str = caml_create_string (offset + slen);\n caml_blit_string(chan.file.data, 0, new_str, 0, clen);\n caml_blit_string(str, 0, new_str, offset, slen);\n chan.file.data = new_str;\n }\n chan.offset += slen;\n chan.file.modified();\n return 0;\n}\n\nfunction caml_ml_open_descriptor_out (fd) {\n var output;\n switch(fd){\n case 1: output=js_print_stdout;break;\n case 2: output=js_print_stderr;break;\n default: output=caml_std_output;\n }\n var data = caml_global_data.fds[fd];\n if(data.flags.rdonly) caml_raise_sys_error(\"fd \"+ fd + \" is readonly\");\n var channel = {\n file:data.file,\n offset:data.offset,\n fd:fd,\n opened:true,\n\n buffer:\"\",\n output : output\n };\n caml_ml_out_channels[channel.fd]=channel;\n return channel;\n}\n\n//Provides: caml_ml_open_descriptor_in\n//Requires: caml_global_data,caml_sys_open,caml_raise_sys_error\nfunction caml_ml_open_descriptor_in (fd) {\n var data = caml_global_data.fds[fd];\n if(data.flags.wronly) caml_raise_sys_error(\"fd \"+ fd + \" is writeonly\");\n\n return {\n file:data.file,\n offset:data.offset,\n fd:fd,\n opened:true,\n refill:null\n };\n}\n\n\n//Provides: caml_ml_set_binary_mode\n//Requires: caml_global_data\nfunction caml_ml_set_binary_mode(chan,mode){\n var data = caml_global_data.fds[chan.fd];\n data.flags.text = !mode\n data.flags.binary = mode\n return 0;\n}\n\n//Input from in_channel\n\n//Provides: caml_ml_close_channel\n//Requires: caml_ml_flush, caml_ml_out_channels\n//Requires: caml_sys_close\nfunction caml_ml_close_channel (channel) {\n caml_ml_flush(channel);\n channel.opened = false;\n delete caml_ml_out_channels[channel.fd];\n caml_sys_close(channel.fd)\n return 0;\n}\n\n//Provides: caml_ml_channel_size\n//Requires: caml_ml_string_length\nfunction caml_ml_channel_size(chan) {\n return caml_ml_string_length(chan.file.data);\n}\n\n//Provides: caml_ml_channel_size_64\n//Requires: caml_ml_channel_size,caml_int64_of_float,caml_ml_string_length\nfunction caml_ml_channel_size_64(chan) {\n return caml_int64_of_float(caml_ml_string_length(chan.file.data));\n}\n\n//Provides: caml_ml_set_channel_output\nfunction caml_ml_set_channel_output(chan,f) {\n chan.output = f;\n return 0;\n}\n\n//Provides: caml_ml_set_channel_refill\nfunction caml_ml_set_channel_refill(chan,f) {\n chan.refill = f;\n return 0;\n}\n\n//Provides: caml_ml_refill_input\n//Requires: caml_ml_string_length, caml_create_string, caml_blit_string\nfunction caml_ml_refill_input (chan) {\n var str = chan.refill();\n var str_len = caml_ml_string_length(str);\n if (str_len == 0) chan.refill = null;\n var old_len = caml_ml_string_length(chan.file.data) - chan.offset;\n if (old_len == 0) {\n chan.file.data = str;\n } else {\n var new_data = caml_create_string(old_len + str_len);\n caml_blit_string(chan.file.data, chan.offset, new_data, 0, old_len);\n caml_blit_string(str, 0, new_data, old_len, str_len);\n chan.file.data = new_data;\n }\n chan.offset = 0;\n return str_len;\n}\n\n//Provides: caml_ml_may_refill_input\n//Requires: caml_ml_string_length, caml_ml_refill_input\nfunction caml_ml_may_refill_input (chan) {\n if (chan.refill == null) return;\n if (caml_ml_string_length(chan.file.data) != chan.offset) return;\n caml_ml_refill_input (chan);\n}\n\n//Provides: caml_ml_input\n//Requires: caml_blit_string, caml_string_of_array, caml_ml_string_length\n//Requires: caml_ml_refill_input\nfunction caml_ml_input (chan, s, i, l) {\n var l2 = caml_ml_string_length(chan.file.data) - chan.offset;\n if (l2 == 0 && chan.refill != null) l2 = caml_ml_refill_input(chan);\n if (l2 < l) l = l2;\n caml_blit_string(chan.file.data, chan.offset, s, i, l);\n chan.offset += l;\n return l;\n}\n\n//Provides: caml_fs_file_content\n//Requires: caml_string_of_array, caml_fs_content, caml_make_path, MlFile\n//Requires: caml_raise_not_found, unix_time\nfunction caml_fs_file_content(name) {\n var path = caml_make_path(name);\n var f = caml_fs_content(path);\n if(f instanceof MlFile){\n var now = unix_time();\n f.atime = now;\n return f.data;\n }\n caml_raise_not_found();\n}\n\n//Provides: caml_input_value\n//Requires: caml_marshal_data_size, caml_input_value_from_string, caml_string_of_array\nfunction caml_input_value (chan) {\n var str = chan.file.data;\n var offset = [chan.offset];\n var _len = caml_marshal_data_size (str, offset[0]);\n var res = caml_input_value_from_string(str, offset);\n chan.offset = offset[0];\n return res;\n}\n\n//Provides: caml_ml_input_char\n//Requires: caml_raise_end_of_file, caml_array_bound_error\n//Requires: caml_ml_string_length, caml_string_get, caml_ml_may_refill_input\nfunction caml_ml_input_char (chan) {\n caml_ml_may_refill_input(chan);\n if (chan.offset >= caml_ml_string_length(chan.file.data))\n caml_raise_end_of_file();\n var c = caml_string_get(chan.file.data, chan.offset);\n chan.offset++;\n return c;\n}\n\n//Provides: caml_ml_input_int\n//Requires: caml_raise_end_of_file\n//Requires: caml_ml_string_length, caml_string_unsafe_get, caml_ml_refill_input\nfunction caml_ml_input_int (chan) {\n var s = chan.file.data, o = chan.offset;\n while ((o + 3) >= caml_ml_string_length(s)) {\n var l = caml_ml_refill_input(chan);\n if (l == 0) caml_raise_end_of_file();\n s = chan.file.data;\n o = chan.offset;\n }\n var r = (caml_string_unsafe_get(s,o) << 24) | (caml_string_unsafe_get(s,o+1) << 16) | (caml_string_unsafe_get(s,o+2) << 8) | (caml_string_unsafe_get(s,o+3));\n chan.offset+=4;\n return r;\n}\n\n//Provides: caml_ml_seek_in\n//Requires: caml_raise_sys_error\nfunction caml_ml_seek_in(chan,pos){\n if (chan.refill != null) caml_raise_sys_error(\"Illegal seek\");\n chan.offset = pos;\n return 0;\n}\n\n//Provides: caml_ml_seek_in_64\n//Requires: caml_int64_to_float, caml_raise_sys_error\nfunction caml_ml_seek_in_64(chan,pos){\n if (chan.refill != null) caml_raise_sys_error(\"Illegal seek\");\n chan.offset = caml_int64_to_float(pos);\n return 0;\n}\n\n//Provides: caml_ml_pos_in\nfunction caml_ml_pos_in(chan) {return chan.offset}\n\n//Provides: caml_ml_pos_in_64\n//Requires: caml_int64_of_float\nfunction caml_ml_pos_in_64(chan) {return caml_int64_of_float(chan.offset)}\n\n//Provides: caml_ml_input_scan_line\n//Requires: caml_array_bound_error, caml_ml_string_length, caml_string_get\n//Requires: caml_ml_may_refill_input\nfunction caml_ml_input_scan_line(chan){\n caml_ml_may_refill_input(chan);\n var p = chan.offset;\n var s = chan.file.data;\n var len = caml_ml_string_length(s);\n if(p >= len) { return 0;}\n while(true) {\n if(p >= len) return - (p - chan.offset);\n if(caml_string_get(s, p) == 10) return p - chan.offset + 1;\n p++;\n }\n}\n\n//Provides: caml_ml_flush\n//Requires: caml_raise_sys_error\nfunction caml_ml_flush (oc) {\n if(! oc.opened) caml_raise_sys_error(\"Cannot flush a closed channel\");\n if(oc.buffer == \"\") return 0;\n if(oc.output) {\n switch(oc.output.length){\n case 2: oc.output(oc,oc.buffer);break;\n default: oc.output(oc.buffer)\n };\n }\n oc.buffer = \"\";\n return 0;\n}\n\n//output to out_channel\n\n//Provides: caml_ml_output\n//Requires: caml_ml_flush,caml_ml_string_length\n//Requires: caml_create_string, caml_blit_string, caml_raise_sys_error\nfunction caml_ml_output (oc,buffer,offset,len) {\n if(! oc.opened) caml_raise_sys_error(\"Cannot output to a closed channel\");\n var string;\n if(offset == 0 && caml_ml_string_length(buffer) == len)\n string = buffer;\n else {\n string = caml_create_string(len);\n caml_blit_string(buffer,offset,string,0,len);\n }\n var jsstring = string.toString();\n var id = jsstring.lastIndexOf(\"\\n\");\n if(id < 0)\n oc.buffer+=jsstring;\n else {\n oc.buffer+=jsstring.substr(0,id+1);\n caml_ml_flush (oc);\n oc.buffer += jsstring.substr(id+1);\n }\n return 0;\n}\n//Provides: caml_ml_output_char\n//Requires: caml_ml_output\n//Requires: caml_new_string\nfunction caml_ml_output_char (oc,c) {\n var s = caml_new_string(String.fromCharCode(c));\n caml_ml_output(oc,s,0,1);\n return 0;\n}\n\n//Provides: caml_output_value\n//Requires: caml_output_value_to_string, caml_ml_output,caml_ml_string_length\nfunction caml_output_value (chan,v,_flags) {\n var s = caml_output_value_to_string(v);\n caml_ml_output(chan,s,0,caml_ml_string_length(s));\n return 0;\n}\n\n\n//Provides: caml_ml_seek_out\nfunction caml_ml_seek_out(chan,pos){\n chan.offset = pos;\n return 0;\n}\n\n//Provides: caml_ml_seek_out_64\n//Requires: caml_int64_to_float\nfunction caml_ml_seek_out_64(chan,pos){\n chan.offset = caml_int64_to_float(pos);\n return 0;\n}\n\n//Provides: caml_ml_pos_out\nfunction caml_ml_pos_out(chan) {return chan.offset}\n\n//Provides: caml_ml_pos_out_64\n//Requires: caml_int64_of_float\nfunction caml_ml_pos_out_64(chan) {\n return caml_int64_of_float (chan.offset);\n}\n\n//Provides: caml_ml_output_int\n//Requires: caml_ml_output\n//Requires: caml_string_of_array\nfunction caml_ml_output_int (oc,i) {\n var arr = [(i>>24) & 0xFF,(i>>16) & 0xFF,(i>>8) & 0xFF,i & 0xFF ];\n var s = caml_string_of_array(arr);\n caml_ml_output(oc,s,0,4);\n return 0\n}\n", "// Js_of_ocaml runtime support\n// http://www.ocsigen.org/js_of_ocaml/\n// Copyright (C) 2014 Jérôme Vouillon, Hugo Heuzard\n// Laboratoire PPS - CNRS Université Paris Diderot\n//\n// This program is free software; you can redistribute it and/or modify\n// it under the terms of the GNU Lesser General Public License as published by\n// the Free Software Foundation, with linking exception;\n// either version 2.1 of the License, or (at your option) any later version.\n//\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n// GNU Lesser General Public License for more details.\n//\n// You should have received a copy of the GNU Lesser General Public License\n// along with this program; if not, write to the Free Software\n// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n///////////// Dummy filesystem\n\n//Provides: caml_current_dir\nvar caml_current_dir = \"/\";\n//Provides: file_inode\nvar file_inode = 0\n\n//Provides: MlDir\n//Requires: file_inode, unix_time\nfunction MlDir(){ this.content={};\n this.inode = file_inode++;\n var now = unix_time();\n this.atime = now;\n this.mtime = now;\n this.ctime = now;\n }\nMlDir.prototype = {\n exists:function(name){return this.content[name]?1:0;},\n mk:function(name,c){this.content[name]=c},\n get:function(name){return this.content[name]},\n list:function(){\n var a = [];\n for(var n in this.content)\n a.push(n);\n return a;\n },\n remove:function(name){delete this.content[name];}\n}\n\n//Provides: MlFile\n//Requires: caml_create_string, file_inode, unix_time\nfunction MlFile(content){ this.data = content;\n this.inode = file_inode++;\n var now = unix_time();\n this.atime = now;\n this.mtime = now;\n this.ctime = now;\n}\nMlFile.prototype = {\n truncate:function(){\n this.data = caml_create_string(0);\n this.modified();\n },\n modified:function() {\n var now = unix_time();\n this.atime = now;\n this.mtime = now;\n }\n}\n\n//Provides: caml_root_dir\n//Requires: MlDir\nvar caml_root_dir = new MlDir();\ncaml_root_dir.mk(\"\",new MlDir());\n\n//Provides: caml_sys_getcwd\n//Requires: caml_current_dir, caml_new_string\nfunction caml_sys_getcwd() { return caml_new_string(caml_current_dir); }\n//Provides: caml_sys_chdir\n//Requires: caml_current_dir, caml_make_path\n//Requires: caml_sys_file_exists, caml_sys_is_directory,caml_raise_no_such_file\nfunction caml_sys_chdir(dir) {\n if(caml_sys_file_exists(dir) && caml_sys_is_directory(dir)){\n var name = caml_make_path(dir);\n name.push(\"\"); // we want the slash a the end\n caml_current_dir = name.join(\"/\");\n return 0;\n }\n else\n caml_raise_no_such_file(dir);\n}\n//Provides: caml_raise_no_such_file\n//Requires: MlString, caml_raise_sys_error\nfunction caml_raise_no_such_file(name){\n name = (name instanceof MlString)?name.toString():name;\n caml_raise_sys_error (name + \": No such file or directory\");\n}\n\n//Provides: caml_raise_not_a_dir\n//Requires: MlString, caml_raise_sys_error\nfunction caml_raise_not_a_dir(name){\n name = (name instanceof MlString)?name.toString():name;\n caml_raise_sys_error (name + \": Not a directory\");\n}\n\n//Provides: caml_make_path\n//Requires: caml_current_dir,MlString\nfunction caml_make_path (name) {\n name=(name instanceof MlString)?name.toString():name;\n if(name.charCodeAt(0) != 47)\n name = caml_current_dir + name;\n var comp = name.split(\"/\");\n var ncomp = []\n for(var i = 0; i1) ncomp.pop(); break;\n case \".\": break;\n case \"\": if(ncomp.length == 0) ncomp.push(\"\"); break;\n default: ncomp.push(comp[i]);break\n }\n }\n ncomp.orig = name;\n return ncomp;\n\n}\n\n\n//Provides: caml_fs_register\n//Requires: MlDir, MlFile, caml_root_dir, caml_make_path, caml_raise_sys_error\n//Requires: MlString, caml_array_of_string\n//Requires: caml_invalid_argument, caml_new_string\n//Requires: caml_string_of_array\n// content can be : MlDIr,MlFile,MlString,Array, string\nfunction caml_fs_register(name,content) {\n var path = caml_make_path(name);\n var dir = caml_root_dir;\n for(var i=0;i10) joo_global_object.console.log(\"trampoline \", c, \"times\")\n return res;\n}\n\n//Provides:caml_trampoline_return\nfunction caml_trampoline_return(f,args) {\n return {joo_tramp:f,joo_args:args};\n}\n\n//Provides: js_print_stdout (const)\nfunction js_print_stdout(s) {\n var g = joo_global_object;\n if (g.process && g.process.stdout && g.process.stdout.write) {\n g.process.stdout.write(s)\n } else {\n // Do not output the last \\n if present\n // as console logging display a newline at the end\n if(s.charCodeAt(s.length - 1) == 10)\n s = s.substr(0,s.length - 1 );\n var v = g.console;\n v && v.log && v.log(s);\n }\n}\n//Provides: js_print_stderr (const)\nfunction js_print_stderr(s) {\n var g = joo_global_object;\n if (g.process && g.process.stdout && g.process.stdout.write) {\n g.process.stderr.write(s)\n } else {\n // Do not output the last \\n if present\n // as console logging display a newline at the end\n if(s.charCodeAt(s.length - 1) == 10)\n s = s.substr(0,s.length - 1 );\n var v = g.console;\n v && v.error && v.error(s);\n }\n}\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* Hash tables *)\n\nexternal seeded_hash_param :\n int -> int -> int -> 'a -> int = \"caml_hash\" \"noalloc\"\nexternal old_hash_param :\n int -> int -> 'a -> int = \"caml_hash_univ_param\" \"noalloc\"\n\nlet hash x = seeded_hash_param 10 100 0 x\nlet hash_param n1 n2 x = seeded_hash_param n1 n2 0 x\nlet seeded_hash seed x = seeded_hash_param 10 100 seed x\n\n(* We do dynamic hashing, and resize the table and rehash the elements\n when buckets become too long. *)\n\ntype ('a, 'b) t =\n { mutable size: int; (* number of entries *)\n mutable data: ('a, 'b) bucketlist array; (* the buckets *)\n mutable seed: int; (* for randomization *)\n initial_size: int; (* initial array size *)\n }\n\nand ('a, 'b) bucketlist =\n Empty\n | Cons of 'a * 'b * ('a, 'b) bucketlist\n\n(* To pick random seeds if requested *)\n\nlet randomized_default =\n let params =\n try Sys.getenv \"OCAMLRUNPARAM\" with Not_found ->\n try Sys.getenv \"CAMLRUNPARAM\" with Not_found -> \"\" in\n String.contains params 'R'\n\nlet randomized = ref randomized_default\n\nlet randomize () = randomized := true\n\nlet prng = lazy (Random.State.make_self_init())\n\n(* Creating a fresh, empty table *)\n\nlet rec power_2_above x n =\n if x >= n then x\n else if x * 2 > Sys.max_array_length then x\n else power_2_above (x * 2) n\n\nlet create ?(random = !randomized) initial_size =\n let s = power_2_above 16 initial_size in\n let seed = if random then Random.State.bits (Lazy.force prng) else 0 in\n { initial_size = s; size = 0; seed = seed; data = Array.make s Empty }\n\nlet clear h =\n h.size <- 0;\n let len = Array.length h.data in\n for i = 0 to len - 1 do\n h.data.(i) <- Empty\n done\n\nlet reset h =\n let len = Array.length h.data in\n if Obj.size (Obj.repr h) < 4 (* compatibility with old hash tables *)\n || len = h.initial_size then\n clear h\n else begin\n h.size <- 0;\n h.data <- Array.make h.initial_size Empty\n end\n\nlet copy h = { h with data = Array.copy h.data }\n\nlet length h = h.size\n\nlet resize indexfun h =\n let odata = h.data in\n let osize = Array.length odata in\n let nsize = osize * 2 in\n if nsize < Sys.max_array_length then begin\n let ndata = Array.make nsize Empty in\n h.data <- ndata; (* so that indexfun sees the new bucket count *)\n let rec insert_bucket = function\n Empty -> ()\n | Cons(key, data, rest) ->\n insert_bucket rest; (* preserve original order of elements *)\n let nidx = indexfun h key in\n ndata.(nidx) <- Cons(key, data, ndata.(nidx)) in\n for i = 0 to osize - 1 do\n insert_bucket odata.(i)\n done\n end\n\nlet key_index h key =\n (* compatibility with old hash tables *)\n if Obj.size (Obj.repr h) >= 3\n then (seeded_hash_param 10 100 h.seed key) land (Array.length h.data - 1)\n else (old_hash_param 10 100 key) mod (Array.length h.data)\n\nlet add h key info =\n let i = key_index h key in\n let bucket = Cons(key, info, h.data.(i)) in\n h.data.(i) <- bucket;\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n\nlet remove h key =\n let rec remove_bucket = function\n | Empty ->\n Empty\n | Cons(k, i, next) ->\n if compare k key = 0\n then begin h.size <- h.size - 1; next end\n else Cons(k, i, remove_bucket next) in\n let i = key_index h key in\n h.data.(i) <- remove_bucket h.data.(i)\n\nlet rec find_rec key = function\n | Empty ->\n raise Not_found\n | Cons(k, d, rest) ->\n if compare key k = 0 then d else find_rec key rest\n\nlet find h key =\n match h.data.(key_index h key) with\n | Empty -> raise Not_found\n | Cons(k1, d1, rest1) ->\n if compare key k1 = 0 then d1 else\n match rest1 with\n | Empty -> raise Not_found\n | Cons(k2, d2, rest2) ->\n if compare key k2 = 0 then d2 else\n match rest2 with\n | Empty -> raise Not_found\n | Cons(k3, d3, rest3) ->\n if compare key k3 = 0 then d3 else find_rec key rest3\n\nlet find_all h key =\n let rec find_in_bucket = function\n | Empty ->\n []\n | Cons(k, d, rest) ->\n if compare k key = 0\n then d :: find_in_bucket rest\n else find_in_bucket rest in\n find_in_bucket h.data.(key_index h key)\n\nlet replace h key info =\n let rec replace_bucket = function\n | Empty ->\n raise Not_found\n | Cons(k, i, next) ->\n if compare k key = 0\n then Cons(key, info, next)\n else Cons(k, i, replace_bucket next) in\n let i = key_index h key in\n let l = h.data.(i) in\n try\n h.data.(i) <- replace_bucket l\n with Not_found ->\n h.data.(i) <- Cons(key, info, l);\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n\nlet mem h key =\n let rec mem_in_bucket = function\n | Empty ->\n false\n | Cons(k, d, rest) ->\n compare k key = 0 || mem_in_bucket rest in\n mem_in_bucket h.data.(key_index h key)\n\nlet iter f h =\n let rec do_bucket = function\n | Empty ->\n ()\n | Cons(k, d, rest) ->\n f k d; do_bucket rest in\n let d = h.data in\n for i = 0 to Array.length d - 1 do\n do_bucket d.(i)\n done\n\nlet fold f h init =\n let rec do_bucket b accu =\n match b with\n Empty ->\n accu\n | Cons(k, d, rest) ->\n do_bucket rest (f k d accu) in\n let d = h.data in\n let accu = ref init in\n for i = 0 to Array.length d - 1 do\n accu := do_bucket d.(i) !accu\n done;\n !accu\n\ntype statistics = {\n num_bindings: int;\n num_buckets: int;\n max_bucket_length: int;\n bucket_histogram: int array\n}\n\nlet rec bucket_length accu = function\n | Empty -> accu\n | Cons(_, _, rest) -> bucket_length (accu + 1) rest\n\nlet stats h =\n let mbl =\n Array.fold_left (fun m b -> max m (bucket_length 0 b)) 0 h.data in\n let histo = Array.make (mbl + 1) 0 in\n Array.iter\n (fun b ->\n let l = bucket_length 0 b in\n histo.(l) <- histo.(l) + 1)\n h.data;\n { num_bindings = h.size;\n num_buckets = Array.length h.data;\n max_bucket_length = mbl;\n bucket_histogram = histo }\n\n(* Functorial interface *)\n\nmodule type HashedType =\n sig\n type t\n val equal: t -> t -> bool\n val hash: t -> int\n end\n\nmodule type SeededHashedType =\n sig\n type t\n val equal: t -> t -> bool\n val hash: int -> t -> int\n end\n\nmodule type S =\n sig\n type key\n type 'a t\n val create: int -> 'a t\n val clear : 'a t -> unit\n val reset : 'a t -> unit\n val copy: 'a t -> 'a t\n val add: 'a t -> key -> 'a -> unit\n val remove: 'a t -> key -> unit\n val find: 'a t -> key -> 'a\n val find_all: 'a t -> key -> 'a list\n val replace : 'a t -> key -> 'a -> unit\n val mem : 'a t -> key -> bool\n val iter: (key -> 'a -> unit) -> 'a t -> unit\n val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n val length: 'a t -> int\n val stats: 'a t -> statistics\n end\n\nmodule type SeededS =\n sig\n type key\n type 'a t\n val create : ?random:bool -> int -> 'a t\n val clear : 'a t -> unit\n val reset : 'a t -> unit\n val copy : 'a t -> 'a t\n val add : 'a t -> key -> 'a -> unit\n val remove : 'a t -> key -> unit\n val find : 'a t -> key -> 'a\n val find_all : 'a t -> key -> 'a list\n val replace : 'a t -> key -> 'a -> unit\n val mem : 'a t -> key -> bool\n val iter : (key -> 'a -> unit) -> 'a t -> unit\n val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b\n val length : 'a t -> int\n val stats: 'a t -> statistics\n end\n\nmodule MakeSeeded(H: SeededHashedType): (SeededS with type key = H.t) =\n struct\n type key = H.t\n type 'a hashtbl = (key, 'a) t\n type 'a t = 'a hashtbl\n let create = create\n let clear = clear\n let reset = reset\n let copy = copy\n\n let key_index h key =\n (H.hash h.seed key) land (Array.length h.data - 1)\n\n let add h key info =\n let i = key_index h key in\n let bucket = Cons(key, info, h.data.(i)) in\n h.data.(i) <- bucket;\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n\n let remove h key =\n let rec remove_bucket = function\n | Empty ->\n Empty\n | Cons(k, i, next) ->\n if H.equal k key\n then begin h.size <- h.size - 1; next end\n else Cons(k, i, remove_bucket next) in\n let i = key_index h key in\n h.data.(i) <- remove_bucket h.data.(i)\n\n let rec find_rec key = function\n | Empty ->\n raise Not_found\n | Cons(k, d, rest) ->\n if H.equal key k then d else find_rec key rest\n\n let find h key =\n match h.data.(key_index h key) with\n | Empty -> raise Not_found\n | Cons(k1, d1, rest1) ->\n if H.equal key k1 then d1 else\n match rest1 with\n | Empty -> raise Not_found\n | Cons(k2, d2, rest2) ->\n if H.equal key k2 then d2 else\n match rest2 with\n | Empty -> raise Not_found\n | Cons(k3, d3, rest3) ->\n if H.equal key k3 then d3 else find_rec key rest3\n\n let find_all h key =\n let rec find_in_bucket = function\n | Empty ->\n []\n | Cons(k, d, rest) ->\n if H.equal k key\n then d :: find_in_bucket rest\n else find_in_bucket rest in\n find_in_bucket h.data.(key_index h key)\n\n let replace h key info =\n let rec replace_bucket = function\n | Empty ->\n raise Not_found\n | Cons(k, i, next) ->\n if H.equal k key\n then Cons(key, info, next)\n else Cons(k, i, replace_bucket next) in\n let i = key_index h key in\n let l = h.data.(i) in\n try\n h.data.(i) <- replace_bucket l\n with Not_found ->\n h.data.(i) <- Cons(key, info, l);\n h.size <- h.size + 1;\n if h.size > Array.length h.data lsl 1 then resize key_index h\n\n let mem h key =\n let rec mem_in_bucket = function\n | Empty ->\n false\n | Cons(k, d, rest) ->\n H.equal k key || mem_in_bucket rest in\n mem_in_bucket h.data.(key_index h key)\n\n let iter = iter\n let fold = fold\n let length = length\n let stats = stats\n end\n\nmodule Make(H: HashedType): (S with type key = H.t) =\n struct\n include MakeSeeded(struct\n type t = H.t\n let equal = H.equal\n let hash (seed: int) x = H.hash x\n end)\n let create sz = create ~random:false sz\n end\n", "(* Padding position. *)\ntype padty =\n | Left (* Text is left justified ('-' option). *)\n | Right (* Text is right justified (no '-' option). *)\n | Zeros (* Text is right justified by zeros (see '0' option). *)\n\n(***)\n\n(* Integer conversion. *)\ntype int_conv =\n | Int_d | Int_pd | Int_sd (* %d | %+d | % d *)\n | Int_i | Int_pi | Int_si (* %i | %+i | % i *)\n | Int_x | Int_Cx (* %x | %#x *)\n | Int_X | Int_CX (* %X | %#X *)\n | Int_o | Int_Co (* %o | %#o *)\n | Int_u (* %u *)\n\n(* Float conversion. *)\ntype float_conv =\n | Float_f | Float_pf | Float_sf (* %f | %+f | % f *)\n | Float_e | Float_pe | Float_se (* %e | %+e | % e *)\n | Float_E | Float_pE | Float_sE (* %E | %+E | % E *)\n | Float_g | Float_pg | Float_sg (* %g | %+g | % g *)\n | Float_G | Float_pG | Float_sG (* %G | %+G | % G *)\n | Float_F (* %F *)\n\n(***)\n\n(* Char sets (see %[...]) are bitmaps implemented as 32-char strings. *)\ntype char_set = string\n\n(***)\n\n(* Counter used in Scanf. *)\ntype counter =\n | Line_counter (* %l *)\n | Char_counter (* %n *)\n | Token_counter (* %N, %L *)\n\n(***)\n\n(* Padding of strings and numbers. *)\ntype ('a, 'b) padding =\n (* No padding (ex: \"%d\") *)\n | No_padding : ('a, 'a) padding\n (* Literal padding (ex: \"%8d\") *)\n | Lit_padding : padty * int -> ('a, 'a) padding\n (* Padding as extra argument (ex: \"%*d\") *)\n | Arg_padding : padty -> (int -> 'a, 'a) padding\n\n(* Some formats, such as %_d,\n only accept an optional number as padding option (no extra argument) *)\ntype pad_option = int option\n\n(* Precision of floats and '0'-padding of integers. *)\ntype ('a, 'b) precision =\n (* No precision (ex: \"%f\") *)\n | No_precision : ('a, 'a) precision\n (* Literal precision (ex: \"%.3f\") *)\n | Lit_precision : int -> ('a, 'a) precision\n (* Precision as extra argument (ex: \"%.*f\") *)\n | Arg_precision : (int -> 'a, 'a) precision\n\n(* Some formats, such as %_f,\n only accept an optional number as precision option (no extra argument) *)\ntype prec_option = int option\n\n(* see the Custom format combinator *)\ntype ('a, 'b, 'c) custom_arity =\n | Custom_zero : ('a, string, 'a) custom_arity\n | Custom_succ : ('a, 'b, 'c) custom_arity ->\n ('a, 'x -> 'b, 'x -> 'c) custom_arity\n\n(***)\n\n(* Relational format types\n\nIn the first format+gadts implementation, the type for %(..%) in the\nfmt GADT was as follows:\n\n| Format_subst : (* %(...%) *)\n pad_option * ('d1, 'q1, 'd2, 'q2) reader_nb_unifier *\n ('x, 'b, 'c, 'd1, 'q1, 'u) fmtty *\n ('u, 'b, 'c, 'q1, 'e1, 'f) fmt ->\n (('x, 'b, 'c, 'd2, 'q2, 'u) format6 -> 'x, 'b, 'c, 'd1, 'e1, 'f) fmt\n\nNotice that the 'u parameter in 'f position in the format argument\n(('x, .., 'u) format6 -> ..) is equal to the 'u parameter in 'a\nposition in the format tail (('u, .., 'f) fmt). This means that the\ntype of the expected format parameter depends of where the %(...%)\nare in the format string:\n\n # Printf.printf \"%(%)\";;\n - : (unit, out_channel, unit, '_a, '_a, unit)\n CamlinternalFormatBasics.format6 -> unit\n = \n # Printf.printf \"%(%)%d\";;\n - : (int -> unit, out_channel, unit, '_a, '_a, int -> unit)\n CamlinternalFormatBasics.format6 -> int -> unit\n = \n\nOn the contrary, the legacy typer gives a clever type that does not\ndepend on the position of %(..%) in the format string. For example,\n%(%) will have the polymorphic type ('a, 'b, 'c, 'd, 'd, 'a): it can\nbe concatenated to any format type, and only enforces the constraint\nthat its 'a and 'f parameters are equal (no format arguments) and 'd\nand 'e are equal (no reader argument).\n\nThe weakening of this parameter type in the GADT version broke user\ncode (in fact it essentially made %(...%) unusable except at the last\nposition of a format). In particular, the following would not work\nanymore:\n\n fun sep ->\n Format.printf \"foo%(%)bar%(%)baz\" sep sep\n\nAs the type-checker would require two *incompatible* types for the %(%)\nin different positions.\n\nThe solution to regain a general type for %(..%) is to generalize this\ntechnique, not only on the 'd, 'e parameters, but on all six\nparameters of a format: we introduce a \"relational\" type\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\nwhose values are proofs that ('a1, .., 'f1) and ('a2, .., 'f2) morally\ncorrespond to the same format type: 'a1 is obtained from 'f1,'b1,'c1\nin the exact same way that 'a2 is obtained from 'f2,'b2,'c2, etc.\n\nFor example, the relation between two format types beginning with a Char\nparameter is as follows:\n\n| Char_ty : (* %c *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n\nIn the general case, the term structure of fmtty_rel is (almost¹)\nisomorphic to the fmtty of the previous implementation: every\nconstructor is re-read with a binary, relational type, instead of the\nprevious unary typing. fmtty can then be re-defined as the diagonal of\nfmtty_rel:\n\n type ('a, 'b, 'c, 'd, 'e, 'f) fmtty =\n ('a, 'b, 'c, 'd, 'e, 'f,\n 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel\n\nOnce we have this fmtty_rel type in place, we can give the more\ngeneral type to %(...%):\n\n| Format_subst : (* %(...%) *)\n pad_option *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt\n\nWe accept any format (('g, 'h, 'i, 'j, 'k, 'l) format6) (this is\ncompletely unrelated to the type of the current format), but also\nrequire a proof that this format is in relation to another format that\nis concatenable to the format tail. When executing a %(...%) format\n(in camlinternalFormat.ml:make_printf or scanf.ml:make_scanf), we\ntranstype the format along this relation using the 'recast' function\nto transpose between related format types.\n\n val recast :\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1) fmt\n -> ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n -> ('a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmt\n\nNOTE ¹: the typing of Format_subst_ty requires not one format type, but\ntwo, one to establish the link between the format argument and the\nfirst six parameters, and the other for the link between the format\nargumant and the last six parameters.\n\n| Format_subst_ty : (* %(...%) *)\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,\n ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel\n\nWhen we generate a format AST, we generate exactly the same witness\nfor both relations, and the witness-conversion functions in\ncamlinternalFormat do rely on this invariant. For example, the\nfunction that proves that the relation is transitive\n\n val trans :\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n -> ('a2, 'b2, 'c2, 'd2, 'e2, 'f2,\n 'a3, 'b3, 'c3, 'd3, 'e3, 'f3) fmtty_rel\n -> ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a3, 'b3, 'c3, 'd3, 'e3, 'f3) fmtty_rel\n\ndoes assume that the two input have exactly the same term structure\n(and is only every used for argument witnesses of the\nFormat_subst_ty constructor).\n*)\n\n(* Type of a block used by the Format pretty-printer. *)\ntype block_type =\n | Pp_hbox (* Horizontal block no line breaking *)\n | Pp_vbox (* Vertical block each break leads to a new line *)\n | Pp_hvbox (* Horizontal-vertical block: same as vbox, except if this block\n is small enough to fit on a single line *)\n | Pp_hovbox (* Horizontal or Vertical block: breaks lead to new line\n only when necessary to print the content of the block *)\n | Pp_box (* Horizontal or Indent block: breaks lead to new line\n only when necessary to print the content of the block, or\n when it leads to a new indentation of the current line *)\n | Pp_fits (* Internal usage: when a block fits on a single line *)\n\n(* Formatting element used by the Format pretty-printter. *)\ntype formatting_lit =\n | Close_box (* @] *)\n | Close_tag (* @} *)\n | Break of string * int * int (* @, | @ | @; | @;<> *)\n | FFlush (* @? *)\n | Force_newline (* @\\n *)\n | Flush_newline (* @. *)\n | Magic_size of string * int (* @ *)\n | Escaped_at (* @@ *)\n | Escaped_percent (* @%% *)\n | Scan_indic of char (* @X *)\n\n(* Formatting element used by the Format pretty-printter. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) formatting_gen =\n | Open_tag : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (* @{ *)\n ('a, 'b, 'c, 'd, 'e, 'f) formatting_gen\n | Open_box : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> (* @[ *)\n ('a, 'b, 'c, 'd, 'e, 'f) formatting_gen\n\n(***)\n\n(* List of format type elements. *)\n(* In particular used to represent %(...%) and %{...%} contents. *)\nand ('a, 'b, 'c, 'd, 'e, 'f) fmtty =\n ('a, 'b, 'c, 'd, 'e, 'f,\n 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel\nand ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel =\n | Char_ty : (* %c *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | String_ty : (* %s *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (string -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n string -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Int_ty : (* %d *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (int -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n int -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Int32_ty : (* %ld *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (int32 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n int32 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Nativeint_ty : (* %nd *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (nativeint -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n nativeint -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Int64_ty : (* %Ld *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (int64 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n int64 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Float_ty : (* %f *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (float -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n float -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Bool_ty : (* %B *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (bool -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n bool -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n\n | Format_arg_ty : (* %{...%} *)\n ('g, 'h, 'i, 'j, 'k, 'l) fmtty *\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Format_subst_ty : (* %(...%) *)\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,\n ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel\n\n (* Printf and Format specific constructors. *)\n | Alpha_ty : (* %a *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('b1 -> 'x -> 'c1) -> 'x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n ('b2 -> 'x -> 'c2) -> 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Theta_ty : (* %t *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n (('b1 -> 'c1) -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n ('b2 -> 'c2) -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n | Any_ty : (* Used for custom formats *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n ('x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel\n\n (* Scanf specific constructor. *)\n | Reader_ty : (* %r *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n ('x -> 'a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,\n 'x -> 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel\n | Ignored_reader_ty : (* %_r *)\n ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->\n ('a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,\n 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel\n\n | End_of_fmtty :\n ('f1, 'b1, 'c1, 'd1, 'd1, 'f1,\n 'f2, 'b2, 'c2, 'd2, 'd2, 'f2) fmtty_rel\n\n(***)\n\n(* List of format elements. *)\nand ('a, 'b, 'c, 'd, 'e, 'f) fmt =\n | Char : (* %c *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Caml_char : (* %C *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | String : (* %s *)\n ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Caml_string : (* %S *)\n ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Int : (* %[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, int -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Int32 : (* %l[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, int32 -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Nativeint : (* %n[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, nativeint -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Int64 : (* %L[dixXuo] *)\n int_conv * ('x, 'y) padding * ('y, int64 -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Float : (* %[feEgGF] *)\n float_conv * ('x, 'y) padding * ('y, float -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'd, 'e, 'f) fmt\n | Bool : (* %[bB] *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (bool -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Flush : (* %! *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n\n | String_literal : (* abc *)\n string * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n | Char_literal : (* x *)\n char * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n\n | Format_arg : (* %{...%} *)\n pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Format_subst : (* %(...%) *)\n pad_option *\n ('g, 'h, 'i, 'j, 'k, 'l,\n 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt\n\n (* Printf and Format specific constructor. *)\n | Alpha : (* %a *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('b -> 'x -> 'c) -> 'x -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Theta : (* %t *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (('b -> 'c) -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n\n (* Format specific constructor: *)\n | Formatting_lit : (* @_ *)\n formatting_lit * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n | Formatting_gen : (* @_ *)\n ('a1, 'b, 'c, 'd1, 'e1, 'f1) formatting_gen *\n ('f1, 'b, 'c, 'e1, 'e2, 'f2) fmt -> ('a1, 'b, 'c, 'd1, 'e2, 'f2) fmt\n\n (* Scanf specific constructors: *)\n | Reader : (* %r *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x -> 'a, 'b, 'c, ('b -> 'x) -> 'd, 'e, 'f) fmt\n | Scan_char_set : (* %[...] *)\n pad_option * char_set * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (string -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Scan_get_counter : (* %[nlNL] *)\n counter * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (int -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Scan_next_char : (* %0c *)\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt\n | Ignored_param : (* %_ *)\n ('a, 'b, 'c, 'd, 'y, 'x) ignored * ('x, 'b, 'c, 'y, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt\n\n (* Custom printing format (PR#6452, GPR#140)\n\n We include a type Custom of \"custom converters\", where an\n arbitrary function can be used to convert one or more\n arguments. There is no syntax for custom converters, it is only\n inteded for custom processors that wish to rely on the\n stdlib-defined format GADTs.\n\n For instance a pre-processor could choose to interpret strings\n prefixed with [\"!\"] as format strings where [%{{ ... }}] is\n a special form to pass a to_string function, so that one could\n write:\n\n {[\n type t = { x : int; y : int }\n\n let string_of_t t = Printf.sprintf \"{ x = %d; y = %d }\" t.x t.y\n\n Printf.printf !\"t = %{{string_of_t}}\" { x = 42; y = 42 }\n ]}\n *)\n | Custom :\n ('a, 'x, 'y) custom_arity * (unit -> 'x) * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('y, 'b, 'c, 'd, 'e, 'f) fmt\n\n (* end of a format specification *)\n | End_of_format :\n ('f, 'b, 'c, 'e, 'e, 'f) fmt\n\n(***)\n\n(* Type for ignored parameters (see \"%_\"). *)\nand ('a, 'b, 'c, 'd, 'e, 'f) ignored =\n | Ignored_char : (* %_c *)\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_caml_char : (* %_C *)\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_string : (* %_s *)\n pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_caml_string : (* %_S *)\n pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_int : (* %_d *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_int32 : (* %_ld *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_nativeint : (* %_nd *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_int64 : (* %_Ld *)\n int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_float : (* %_f *)\n pad_option * prec_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_bool : (* %_B *)\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_format_arg : (* %_{...%} *)\n pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty ->\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_format_subst : (* %_(...%) *)\n pad_option * ('a, 'b, 'c, 'd, 'e, 'f) fmtty ->\n ('a, 'b, 'c, 'd, 'e, 'f) ignored\n | Ignored_reader : (* %_r *)\n ('a, 'b, 'c, ('b -> 'x) -> 'd, 'd, 'a) ignored\n | Ignored_scan_char_set : (* %_[...] *)\n pad_option * char_set -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_scan_get_counter : (* %_[nlNL] *)\n counter -> ('a, 'b, 'c, 'd, 'd, 'a) ignored\n | Ignored_scan_next_char : (* %_0c *)\n ('a, 'b, 'c, 'd, 'd, 'a) ignored\n\nand ('a, 'b, 'c, 'd, 'e, 'f) format6 =\n Format of ('a, 'b, 'c, 'd, 'e, 'f) fmt * string\n\nlet rec erase_rel : type a b c d e f g h i j k l .\n (a, b, c, d, e, f,\n g, h, i, j, k, l) fmtty_rel -> (a, b, c, d, e, f) fmtty\n= function\n | Char_ty rest ->\n Char_ty (erase_rel rest)\n | String_ty rest ->\n String_ty (erase_rel rest)\n | Int_ty rest ->\n Int_ty (erase_rel rest)\n | Int32_ty rest ->\n Int32_ty (erase_rel rest)\n | Int64_ty rest ->\n Int64_ty (erase_rel rest)\n | Nativeint_ty rest ->\n Nativeint_ty (erase_rel rest)\n | Float_ty rest ->\n Float_ty (erase_rel rest)\n | Bool_ty rest ->\n Bool_ty (erase_rel rest)\n | Format_arg_ty (ty, rest) ->\n Format_arg_ty (ty, erase_rel rest)\n | Format_subst_ty (ty1, ty2, rest) ->\n Format_subst_ty (ty1, ty1, erase_rel rest)\n | Alpha_ty rest ->\n Alpha_ty (erase_rel rest)\n | Theta_ty rest ->\n Theta_ty (erase_rel rest)\n | Any_ty rest ->\n Any_ty (erase_rel rest)\n | Reader_ty rest ->\n Reader_ty (erase_rel rest)\n | Ignored_reader_ty rest ->\n Ignored_reader_ty (erase_rel rest)\n | End_of_fmtty -> End_of_fmtty\n\n(******************************************************************************)\n (* Format type concatenation *)\n\n(* Concatenate two format types. *)\n(* Used by:\n * reader_nb_unifier_of_fmtty to count readers in an fmtty,\n * Scanf.take_fmtty_format_readers to extract readers inside %(...%),\n * CamlinternalFormat.fmtty_of_ignored_format to extract format type. *)\n\n(*\nlet rec concat_fmtty : type a b c d e f g h .\n (a, b, c, d, e, f) fmtty ->\n (f, b, c, e, g, h) fmtty ->\n (a, b, c, d, g, h) fmtty =\n*)\nlet rec concat_fmtty :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2\n g1 j1 g2 j2\n .\n (g1, b1, c1, j1, d1, a1,\n g2, b2, c2, j2, d2, a2) fmtty_rel ->\n (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel ->\n (g1, b1, c1, j1, e1, f1,\n g2, b2, c2, j2, e2, f2) fmtty_rel =\nfun fmtty1 fmtty2 -> match fmtty1 with\n | Char_ty rest ->\n Char_ty (concat_fmtty rest fmtty2)\n | String_ty rest ->\n String_ty (concat_fmtty rest fmtty2)\n | Int_ty rest ->\n Int_ty (concat_fmtty rest fmtty2)\n | Int32_ty rest ->\n Int32_ty (concat_fmtty rest fmtty2)\n | Nativeint_ty rest ->\n Nativeint_ty (concat_fmtty rest fmtty2)\n | Int64_ty rest ->\n Int64_ty (concat_fmtty rest fmtty2)\n | Float_ty rest ->\n Float_ty (concat_fmtty rest fmtty2)\n | Bool_ty rest ->\n Bool_ty (concat_fmtty rest fmtty2)\n | Alpha_ty rest ->\n Alpha_ty (concat_fmtty rest fmtty2)\n | Theta_ty rest ->\n Theta_ty (concat_fmtty rest fmtty2)\n | Any_ty rest ->\n Any_ty (concat_fmtty rest fmtty2)\n | Reader_ty rest ->\n Reader_ty (concat_fmtty rest fmtty2)\n | Ignored_reader_ty rest ->\n Ignored_reader_ty (concat_fmtty rest fmtty2)\n | Format_arg_ty (ty, rest) ->\n Format_arg_ty (ty, concat_fmtty rest fmtty2)\n | Format_subst_ty (ty1, ty2, rest) ->\n Format_subst_ty (ty1, ty2, concat_fmtty rest fmtty2)\n | End_of_fmtty -> fmtty2\n\n(******************************************************************************)\n (* Format concatenation *)\n\n(* Concatenate two formats. *)\nlet rec concat_fmt : type a b c d e f g h .\n (a, b, c, d, e, f) fmt ->\n (f, b, c, e, g, h) fmt ->\n (a, b, c, d, g, h) fmt =\nfun fmt1 fmt2 -> match fmt1 with\n | String (pad, rest) ->\n String (pad, concat_fmt rest fmt2)\n | Caml_string (pad, rest) ->\n Caml_string (pad, concat_fmt rest fmt2)\n\n | Int (iconv, pad, prec, rest) ->\n Int (iconv, pad, prec, concat_fmt rest fmt2)\n | Int32 (iconv, pad, prec, rest) ->\n Int32 (iconv, pad, prec, concat_fmt rest fmt2)\n | Nativeint (iconv, pad, prec, rest) ->\n Nativeint (iconv, pad, prec, concat_fmt rest fmt2)\n | Int64 (iconv, pad, prec, rest) ->\n Int64 (iconv, pad, prec, concat_fmt rest fmt2)\n | Float (fconv, pad, prec, rest) ->\n Float (fconv, pad, prec, concat_fmt rest fmt2)\n\n | Char (rest) ->\n Char (concat_fmt rest fmt2)\n | Caml_char rest ->\n Caml_char (concat_fmt rest fmt2)\n | Bool rest ->\n Bool (concat_fmt rest fmt2)\n | Alpha rest ->\n Alpha (concat_fmt rest fmt2)\n | Theta rest ->\n Theta (concat_fmt rest fmt2)\n | Custom (arity, f, rest) ->\n Custom (arity, f, concat_fmt rest fmt2)\n | Reader rest ->\n Reader (concat_fmt rest fmt2)\n | Flush rest ->\n Flush (concat_fmt rest fmt2)\n\n | String_literal (str, rest) ->\n String_literal (str, concat_fmt rest fmt2)\n | Char_literal (chr, rest) ->\n Char_literal (chr, concat_fmt rest fmt2)\n\n | Format_arg (pad, fmtty, rest) ->\n Format_arg (pad, fmtty, concat_fmt rest fmt2)\n | Format_subst (pad, fmtty, rest) ->\n Format_subst (pad, fmtty, concat_fmt rest fmt2)\n\n | Scan_char_set (width_opt, char_set, rest) ->\n Scan_char_set (width_opt, char_set, concat_fmt rest fmt2)\n | Scan_get_counter (counter, rest) ->\n Scan_get_counter (counter, concat_fmt rest fmt2)\n | Scan_next_char (rest) ->\n Scan_next_char (concat_fmt rest fmt2)\n | Ignored_param (ign, rest) ->\n Ignored_param (ign, concat_fmt rest fmt2)\n\n | Formatting_lit (fmting_lit, rest) ->\n Formatting_lit (fmting_lit, concat_fmt rest fmt2)\n | Formatting_gen (fmting_gen, rest) ->\n Formatting_gen (fmting_gen, concat_fmt rest fmt2)\n\n | End_of_format ->\n fmt2\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* type 'a option = None | Some of 'a *)\n\n(* Exceptions *)\n\nexternal register_named_value : string -> 'a -> unit\n = \"caml_register_named_value\"\n\nlet () =\n (* for asmrun/fail.c *)\n register_named_value \"Pervasives.array_bound_error\"\n (Invalid_argument \"index out of bounds\")\n\n\nexternal raise : exn -> 'a = \"%raise\"\nexternal raise_notrace : exn -> 'a = \"%raise_notrace\"\n\nlet failwith s = raise(Failure s)\nlet invalid_arg s = raise(Invalid_argument s)\n\nexception Exit\n\n(* Composition operators *)\n\nexternal ( |> ) : 'a -> ('a -> 'b) -> 'b = \"%revapply\"\nexternal ( @@ ) : ('a -> 'b) -> 'a -> 'b = \"%apply\"\n\n(* Debugging *)\n\nexternal __LOC__ : string = \"%loc_LOC\"\nexternal __FILE__ : string = \"%loc_FILE\"\nexternal __LINE__ : int = \"%loc_LINE\"\nexternal __MODULE__ : string = \"%loc_MODULE\"\nexternal __POS__ : string * int * int * int = \"%loc_POS\"\n\nexternal __LOC_OF__ : 'a -> string * 'a = \"%loc_LOC\"\nexternal __LINE_OF__ : 'a -> int * 'a = \"%loc_LINE\"\nexternal __POS_OF__ : 'a -> (string * int * int * int) * 'a = \"%loc_POS\"\n\n(* Comparisons *)\n\nexternal ( = ) : 'a -> 'a -> bool = \"%equal\"\nexternal ( <> ) : 'a -> 'a -> bool = \"%notequal\"\nexternal ( < ) : 'a -> 'a -> bool = \"%lessthan\"\nexternal ( > ) : 'a -> 'a -> bool = \"%greaterthan\"\nexternal ( <= ) : 'a -> 'a -> bool = \"%lessequal\"\nexternal ( >= ) : 'a -> 'a -> bool = \"%greaterequal\"\nexternal compare : 'a -> 'a -> int = \"%compare\"\n\nlet min x y = if x <= y then x else y\nlet max x y = if x >= y then x else y\n\nexternal ( == ) : 'a -> 'a -> bool = \"%eq\"\nexternal ( != ) : 'a -> 'a -> bool = \"%noteq\"\n\n(* Boolean operations *)\n\nexternal not : bool -> bool = \"%boolnot\"\nexternal ( & ) : bool -> bool -> bool = \"%sequand\"\nexternal ( && ) : bool -> bool -> bool = \"%sequand\"\nexternal ( or ) : bool -> bool -> bool = \"%sequor\"\nexternal ( || ) : bool -> bool -> bool = \"%sequor\"\n\n(* Integer operations *)\n\nexternal ( ~- ) : int -> int = \"%negint\"\nexternal ( ~+ ) : int -> int = \"%identity\"\nexternal succ : int -> int = \"%succint\"\nexternal pred : int -> int = \"%predint\"\nexternal ( + ) : int -> int -> int = \"%addint\"\nexternal ( - ) : int -> int -> int = \"%subint\"\nexternal ( * ) : int -> int -> int = \"%mulint\"\nexternal ( / ) : int -> int -> int = \"%divint\"\nexternal ( mod ) : int -> int -> int = \"%modint\"\n\nlet abs x = if x >= 0 then x else -x\n\nexternal ( land ) : int -> int -> int = \"%andint\"\nexternal ( lor ) : int -> int -> int = \"%orint\"\nexternal ( lxor ) : int -> int -> int = \"%xorint\"\n\nlet lnot x = x lxor (-1)\n\nexternal ( lsl ) : int -> int -> int = \"%lslint\"\nexternal ( lsr ) : int -> int -> int = \"%lsrint\"\nexternal ( asr ) : int -> int -> int = \"%asrint\"\n\nlet max_int = (-1) lsr 1\nlet min_int = max_int + 1\n\n(* Floating-point operations *)\n\nexternal ( ~-. ) : float -> float = \"%negfloat\"\nexternal ( ~+. ) : float -> float = \"%identity\"\nexternal ( +. ) : float -> float -> float = \"%addfloat\"\nexternal ( -. ) : float -> float -> float = \"%subfloat\"\nexternal ( *. ) : float -> float -> float = \"%mulfloat\"\nexternal ( /. ) : float -> float -> float = \"%divfloat\"\nexternal ( ** ) : float -> float -> float = \"caml_power_float\" \"pow\" \"float\"\nexternal exp : float -> float = \"caml_exp_float\" \"exp\" \"float\"\nexternal expm1 : float -> float = \"caml_expm1_float\" \"caml_expm1\" \"float\"\nexternal acos : float -> float = \"caml_acos_float\" \"acos\" \"float\"\nexternal asin : float -> float = \"caml_asin_float\" \"asin\" \"float\"\nexternal atan : float -> float = \"caml_atan_float\" \"atan\" \"float\"\nexternal atan2 : float -> float -> float = \"caml_atan2_float\" \"atan2\" \"float\"\nexternal hypot : float -> float -> float\n = \"caml_hypot_float\" \"caml_hypot\" \"float\"\nexternal cos : float -> float = \"caml_cos_float\" \"cos\" \"float\"\nexternal cosh : float -> float = \"caml_cosh_float\" \"cosh\" \"float\"\nexternal log : float -> float = \"caml_log_float\" \"log\" \"float\"\nexternal log10 : float -> float = \"caml_log10_float\" \"log10\" \"float\"\nexternal log1p : float -> float = \"caml_log1p_float\" \"caml_log1p\" \"float\"\nexternal sin : float -> float = \"caml_sin_float\" \"sin\" \"float\"\nexternal sinh : float -> float = \"caml_sinh_float\" \"sinh\" \"float\"\nexternal sqrt : float -> float = \"caml_sqrt_float\" \"sqrt\" \"float\"\nexternal tan : float -> float = \"caml_tan_float\" \"tan\" \"float\"\nexternal tanh : float -> float = \"caml_tanh_float\" \"tanh\" \"float\"\nexternal ceil : float -> float = \"caml_ceil_float\" \"ceil\" \"float\"\nexternal floor : float -> float = \"caml_floor_float\" \"floor\" \"float\"\nexternal abs_float : float -> float = \"%absfloat\"\nexternal copysign : float -> float -> float\n = \"caml_copysign_float\" \"caml_copysign\" \"float\"\nexternal mod_float : float -> float -> float = \"caml_fmod_float\" \"fmod\" \"float\"\nexternal frexp : float -> float * int = \"caml_frexp_float\"\nexternal ldexp : float -> int -> float = \"caml_ldexp_float\"\nexternal modf : float -> float * float = \"caml_modf_float\"\nexternal float : int -> float = \"%floatofint\"\nexternal float_of_int : int -> float = \"%floatofint\"\nexternal truncate : float -> int = \"%intoffloat\"\nexternal int_of_float : float -> int = \"%intoffloat\"\nexternal float_of_bits : int64 -> float = \"caml_int64_float_of_bits\"\nlet infinity =\n float_of_bits 0x7F_F0_00_00_00_00_00_00L\nlet neg_infinity =\n float_of_bits 0xFF_F0_00_00_00_00_00_00L\nlet nan =\n float_of_bits 0x7F_F0_00_00_00_00_00_01L\nlet max_float =\n float_of_bits 0x7F_EF_FF_FF_FF_FF_FF_FFL\nlet min_float =\n float_of_bits 0x00_10_00_00_00_00_00_00L\nlet epsilon_float =\n float_of_bits 0x3C_B0_00_00_00_00_00_00L\n\ntype fpclass =\n FP_normal\n | FP_subnormal\n | FP_zero\n | FP_infinite\n | FP_nan\nexternal classify_float : float -> fpclass = \"caml_classify_float\"\n\n(* String and byte sequence operations -- more in modules String and Bytes *)\n\nexternal string_length : string -> int = \"%string_length\"\nexternal bytes_length : bytes -> int = \"%string_length\"\nexternal bytes_create : int -> bytes = \"caml_create_string\"\nexternal string_blit : string -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" \"noalloc\"\nexternal bytes_blit : bytes -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" \"noalloc\"\nexternal bytes_unsafe_to_string : bytes -> string = \"%identity\"\nexternal bytes_unsafe_of_string : string -> bytes = \"%identity\"\n\nlet ( ^ ) s1 s2 =\n let l1 = string_length s1 and l2 = string_length s2 in\n let s = bytes_create (l1 + l2) in\n string_blit s1 0 s 0 l1;\n string_blit s2 0 s l1 l2;\n bytes_unsafe_to_string s\n\n(* Character operations -- more in module Char *)\n\nexternal int_of_char : char -> int = \"%identity\"\nexternal unsafe_char_of_int : int -> char = \"%identity\"\nlet char_of_int n =\n if n < 0 || n > 255 then invalid_arg \"char_of_int\" else unsafe_char_of_int n\n\n(* Unit operations *)\n\nexternal ignore : 'a -> unit = \"%ignore\"\n\n(* Pair operations *)\n\nexternal fst : 'a * 'b -> 'a = \"%field0\"\nexternal snd : 'a * 'b -> 'b = \"%field1\"\n\n(* References *)\n\ntype 'a ref = { mutable contents : 'a }\nexternal ref : 'a -> 'a ref = \"%makemutable\"\nexternal ( ! ) : 'a ref -> 'a = \"%field0\"\nexternal ( := ) : 'a ref -> 'a -> unit = \"%setfield0\"\nexternal incr : int ref -> unit = \"%incr\"\nexternal decr : int ref -> unit = \"%decr\"\n\n(* String conversion functions *)\n\nexternal format_int : string -> int -> string = \"caml_format_int\"\nexternal format_float : string -> float -> string = \"caml_format_float\"\n\nlet string_of_bool b =\n if b then \"true\" else \"false\"\nlet bool_of_string = function\n | \"true\" -> true\n | \"false\" -> false\n | _ -> invalid_arg \"bool_of_string\"\n\nlet string_of_int n =\n format_int \"%d\" n\n\nexternal int_of_string : string -> int = \"caml_int_of_string\"\nexternal string_get : string -> int -> char = \"%string_safe_get\"\n\nlet valid_float_lexem s =\n let l = string_length s in\n let rec loop i =\n if i >= l then s ^ \".\" else\n match string_get s i with\n | '0' .. '9' | '-' -> loop (i + 1)\n | _ -> s\n in\n loop 0\n;;\n\nlet string_of_float f = valid_float_lexem (format_float \"%.12g\" f);;\n\nexternal float_of_string : string -> float = \"caml_float_of_string\"\n\n(* List operations -- more in module List *)\n\nlet rec ( @ ) l1 l2 =\n match l1 with\n [] -> l2\n | hd :: tl -> hd :: (tl @ l2)\n\n(* I/O operations *)\n\ntype in_channel\ntype out_channel\n\nexternal open_descriptor_out : int -> out_channel\n = \"caml_ml_open_descriptor_out\"\nexternal open_descriptor_in : int -> in_channel = \"caml_ml_open_descriptor_in\"\n\nlet stdin = open_descriptor_in 0\nlet stdout = open_descriptor_out 1\nlet stderr = open_descriptor_out 2\n\n(* General output functions *)\n\ntype open_flag =\n Open_rdonly | Open_wronly | Open_append\n | Open_creat | Open_trunc | Open_excl\n | Open_binary | Open_text | Open_nonblock\n\nexternal open_desc : string -> open_flag list -> int -> int = \"caml_sys_open\"\n\nlet open_out_gen mode perm name =\n open_descriptor_out(open_desc name mode perm)\n\nlet open_out name =\n open_out_gen [Open_wronly; Open_creat; Open_trunc; Open_text] 0o666 name\n\nlet open_out_bin name =\n open_out_gen [Open_wronly; Open_creat; Open_trunc; Open_binary] 0o666 name\n\nexternal flush : out_channel -> unit = \"caml_ml_flush\"\n\nexternal out_channels_list : unit -> out_channel list\n = \"caml_ml_out_channels_list\"\n\nlet flush_all () =\n let rec iter = function\n [] -> ()\n | a :: l -> (try flush a with _ -> ()); iter l\n in iter (out_channels_list ())\n\nexternal unsafe_output : out_channel -> bytes -> int -> int -> unit\n = \"caml_ml_output\"\nexternal unsafe_output_string : out_channel -> string -> int -> int -> unit\n = \"caml_ml_output\"\n\nexternal output_char : out_channel -> char -> unit = \"caml_ml_output_char\"\n\nlet output_bytes oc s =\n unsafe_output oc s 0 (bytes_length s)\n\nlet output_string oc s =\n unsafe_output_string oc s 0 (string_length s)\n\nlet output oc s ofs len =\n if ofs < 0 || len < 0 || ofs > bytes_length s - len\n then invalid_arg \"output\"\n else unsafe_output oc s ofs len\n\nlet output_substring oc s ofs len =\n if ofs < 0 || len < 0 || ofs > string_length s - len\n then invalid_arg \"output_substring\"\n else unsafe_output_string oc s ofs len\n\nexternal output_byte : out_channel -> int -> unit = \"caml_ml_output_char\"\nexternal output_binary_int : out_channel -> int -> unit = \"caml_ml_output_int\"\n\nexternal marshal_to_channel : out_channel -> 'a -> unit list -> unit\n = \"caml_output_value\"\nlet output_value chan v = marshal_to_channel chan v []\n\nexternal seek_out : out_channel -> int -> unit = \"caml_ml_seek_out\"\nexternal pos_out : out_channel -> int = \"caml_ml_pos_out\"\nexternal out_channel_length : out_channel -> int = \"caml_ml_channel_size\"\nexternal close_out_channel : out_channel -> unit = \"caml_ml_close_channel\"\nlet close_out oc = flush oc; close_out_channel oc\nlet close_out_noerr oc =\n (try flush oc with _ -> ());\n (try close_out_channel oc with _ -> ())\nexternal set_binary_mode_out : out_channel -> bool -> unit\n = \"caml_ml_set_binary_mode\"\n\n(* General input functions *)\n\nlet open_in_gen mode perm name =\n open_descriptor_in(open_desc name mode perm)\n\nlet open_in name =\n open_in_gen [Open_rdonly; Open_text] 0 name\n\nlet open_in_bin name =\n open_in_gen [Open_rdonly; Open_binary] 0 name\n\nexternal input_char : in_channel -> char = \"caml_ml_input_char\"\n\nexternal unsafe_input : in_channel -> bytes -> int -> int -> int\n = \"caml_ml_input\"\n\nlet input ic s ofs len =\n if ofs < 0 || len < 0 || ofs > bytes_length s - len\n then invalid_arg \"input\"\n else unsafe_input ic s ofs len\n\nlet rec unsafe_really_input ic s ofs len =\n if len <= 0 then () else begin\n let r = unsafe_input ic s ofs len in\n if r = 0\n then raise End_of_file\n else unsafe_really_input ic s (ofs + r) (len - r)\n end\n\nlet really_input ic s ofs len =\n if ofs < 0 || len < 0 || ofs > bytes_length s - len\n then invalid_arg \"really_input\"\n else unsafe_really_input ic s ofs len\n\nlet really_input_string ic len =\n let s = bytes_create len in\n really_input ic s 0 len;\n bytes_unsafe_to_string s\n\nexternal input_scan_line : in_channel -> int = \"caml_ml_input_scan_line\"\n\nlet input_line chan =\n let rec build_result buf pos = function\n [] -> buf\n | hd :: tl ->\n let len = bytes_length hd in\n bytes_blit hd 0 buf (pos - len) len;\n build_result buf (pos - len) tl in\n let rec scan accu len =\n let n = input_scan_line chan in\n if n = 0 then begin (* n = 0: we are at EOF *)\n match accu with\n [] -> raise End_of_file\n | _ -> build_result (bytes_create len) len accu\n end else if n > 0 then begin (* n > 0: newline found in buffer *)\n let res = bytes_create (n - 1) in\n ignore (unsafe_input chan res 0 (n - 1));\n ignore (input_char chan); (* skip the newline *)\n match accu with\n [] -> res\n | _ -> let len = len + n - 1 in\n build_result (bytes_create len) len (res :: accu)\n end else begin (* n < 0: newline not found *)\n let beg = bytes_create (-n) in\n ignore(unsafe_input chan beg 0 (-n));\n scan (beg :: accu) (len - n)\n end\n in bytes_unsafe_to_string (scan [] 0)\n\nexternal input_byte : in_channel -> int = \"caml_ml_input_char\"\nexternal input_binary_int : in_channel -> int = \"caml_ml_input_int\"\nexternal input_value : in_channel -> 'a = \"caml_input_value\"\nexternal seek_in : in_channel -> int -> unit = \"caml_ml_seek_in\"\nexternal pos_in : in_channel -> int = \"caml_ml_pos_in\"\nexternal in_channel_length : in_channel -> int = \"caml_ml_channel_size\"\nexternal close_in : in_channel -> unit = \"caml_ml_close_channel\"\nlet close_in_noerr ic = (try close_in ic with _ -> ());;\nexternal set_binary_mode_in : in_channel -> bool -> unit\n = \"caml_ml_set_binary_mode\"\n\n(* Output functions on standard output *)\n\nlet print_char c = output_char stdout c\nlet print_string s = output_string stdout s\nlet print_bytes s = output_bytes stdout s\nlet print_int i = output_string stdout (string_of_int i)\nlet print_float f = output_string stdout (string_of_float f)\nlet print_endline s =\n output_string stdout s; output_char stdout '\\n'; flush stdout\nlet print_newline () = output_char stdout '\\n'; flush stdout\n\n(* Output functions on standard error *)\n\nlet prerr_char c = output_char stderr c\nlet prerr_string s = output_string stderr s\nlet prerr_bytes s = output_bytes stderr s\nlet prerr_int i = output_string stderr (string_of_int i)\nlet prerr_float f = output_string stderr (string_of_float f)\nlet prerr_endline s =\n output_string stderr s; output_char stderr '\\n'; flush stderr\nlet prerr_newline () = output_char stderr '\\n'; flush stderr\n\n(* Input functions on standard input *)\n\nlet read_line () = flush stdout; input_line stdin\nlet read_int () = int_of_string(read_line())\nlet read_float () = float_of_string(read_line())\n\n(* Operations on large files *)\n\nmodule LargeFile =\n struct\n external seek_out : out_channel -> int64 -> unit = \"caml_ml_seek_out_64\"\n external pos_out : out_channel -> int64 = \"caml_ml_pos_out_64\"\n external out_channel_length : out_channel -> int64\n = \"caml_ml_channel_size_64\"\n external seek_in : in_channel -> int64 -> unit = \"caml_ml_seek_in_64\"\n external pos_in : in_channel -> int64 = \"caml_ml_pos_in_64\"\n external in_channel_length : in_channel -> int64 = \"caml_ml_channel_size_64\"\n end\n\n(* Formats *)\n\ntype ('a, 'b, 'c, 'd, 'e, 'f) format6\n = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6\n = Format of ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmt\n * string\n\ntype ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6\n\ntype ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4\n\nlet string_of_format (Format (fmt, str)) = str\n\nexternal format_of_string :\n ('a, 'b, 'c, 'd, 'e, 'f) format6 ->\n ('a, 'b, 'c, 'd, 'e, 'f) format6 = \"%identity\"\n\nlet (^^) (Format (fmt1, str1)) (Format (fmt2, str2)) =\n Format (CamlinternalFormatBasics.concat_fmt fmt1 fmt2,\n str1 ^ \"%,\" ^ str2)\n\n(* Miscellaneous *)\n\nexternal sys_exit : int -> 'a = \"caml_sys_exit\"\n\nlet exit_function = ref flush_all\n\nlet at_exit f =\n let g = !exit_function in\n exit_function := (fun () -> f(); g())\n\nlet do_at_exit () = (!exit_function) ()\n\nlet exit retcode =\n do_at_exit ();\n sys_exit retcode\n\nlet _ = register_named_value \"Pervasives.do_at_exit\" do_at_exit\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* List operations *)\n\nlet rec length_aux len = function\n [] -> len\n | a::l -> length_aux (len + 1) l\n\nlet length l = length_aux 0 l\n\nlet hd = function\n [] -> failwith \"hd\"\n | a::l -> a\n\nlet tl = function\n [] -> failwith \"tl\"\n | a::l -> l\n\nlet nth l n =\n if n < 0 then invalid_arg \"List.nth\" else\n let rec nth_aux l n =\n match l with\n | [] -> failwith \"nth\"\n | a::l -> if n = 0 then a else nth_aux l (n-1)\n in nth_aux l n\n\nlet append = (@)\n\nlet rec rev_append l1 l2 =\n match l1 with\n [] -> l2\n | a :: l -> rev_append l (a :: l2)\n\nlet rev l = rev_append l []\n\nlet rec flatten = function\n [] -> []\n | l::r -> l @ flatten r\n\nlet concat = flatten\n\nlet rec map f = function\n [] -> []\n | a::l -> let r = f a in r :: map f l\n\nlet rec mapi i f = function\n [] -> []\n | a::l -> let r = f i a in r :: mapi (i + 1) f l\n\nlet mapi f l = mapi 0 f l\n\nlet rev_map f l =\n let rec rmap_f accu = function\n | [] -> accu\n | a::l -> rmap_f (f a :: accu) l\n in\n rmap_f [] l\n;;\n\nlet rec iter f = function\n [] -> ()\n | a::l -> f a; iter f l\n\nlet rec iteri i f = function\n [] -> ()\n | a::l -> f i a; iteri (i + 1) f l\n\nlet iteri f l = iteri 0 f l\n\nlet rec fold_left f accu l =\n match l with\n [] -> accu\n | a::l -> fold_left f (f accu a) l\n\nlet rec fold_right f l accu =\n match l with\n [] -> accu\n | a::l -> f a (fold_right f l accu)\n\nlet rec map2 f l1 l2 =\n match (l1, l2) with\n ([], []) -> []\n | (a1::l1, a2::l2) -> let r = f a1 a2 in r :: map2 f l1 l2\n | (_, _) -> invalid_arg \"List.map2\"\n\nlet rev_map2 f l1 l2 =\n let rec rmap2_f accu l1 l2 =\n match (l1, l2) with\n | ([], []) -> accu\n | (a1::l1, a2::l2) -> rmap2_f (f a1 a2 :: accu) l1 l2\n | (_, _) -> invalid_arg \"List.rev_map2\"\n in\n rmap2_f [] l1 l2\n;;\n\nlet rec iter2 f l1 l2 =\n match (l1, l2) with\n ([], []) -> ()\n | (a1::l1, a2::l2) -> f a1 a2; iter2 f l1 l2\n | (_, _) -> invalid_arg \"List.iter2\"\n\nlet rec fold_left2 f accu l1 l2 =\n match (l1, l2) with\n ([], []) -> accu\n | (a1::l1, a2::l2) -> fold_left2 f (f accu a1 a2) l1 l2\n | (_, _) -> invalid_arg \"List.fold_left2\"\n\nlet rec fold_right2 f l1 l2 accu =\n match (l1, l2) with\n ([], []) -> accu\n | (a1::l1, a2::l2) -> f a1 a2 (fold_right2 f l1 l2 accu)\n | (_, _) -> invalid_arg \"List.fold_right2\"\n\nlet rec for_all p = function\n [] -> true\n | a::l -> p a && for_all p l\n\nlet rec exists p = function\n [] -> false\n | a::l -> p a || exists p l\n\nlet rec for_all2 p l1 l2 =\n match (l1, l2) with\n ([], []) -> true\n | (a1::l1, a2::l2) -> p a1 a2 && for_all2 p l1 l2\n | (_, _) -> invalid_arg \"List.for_all2\"\n\nlet rec exists2 p l1 l2 =\n match (l1, l2) with\n ([], []) -> false\n | (a1::l1, a2::l2) -> p a1 a2 || exists2 p l1 l2\n | (_, _) -> invalid_arg \"List.exists2\"\n\nlet rec mem x = function\n [] -> false\n | a::l -> compare a x = 0 || mem x l\n\nlet rec memq x = function\n [] -> false\n | a::l -> a == x || memq x l\n\nlet rec assoc x = function\n [] -> raise Not_found\n | (a,b)::l -> if compare a x = 0 then b else assoc x l\n\nlet rec assq x = function\n [] -> raise Not_found\n | (a,b)::l -> if a == x then b else assq x l\n\nlet rec mem_assoc x = function\n | [] -> false\n | (a, b) :: l -> compare a x = 0 || mem_assoc x l\n\nlet rec mem_assq x = function\n | [] -> false\n | (a, b) :: l -> a == x || mem_assq x l\n\nlet rec remove_assoc x = function\n | [] -> []\n | (a, b as pair) :: l ->\n if compare a x = 0 then l else pair :: remove_assoc x l\n\nlet rec remove_assq x = function\n | [] -> []\n | (a, b as pair) :: l -> if a == x then l else pair :: remove_assq x l\n\nlet rec find p = function\n | [] -> raise Not_found\n | x :: l -> if p x then x else find p l\n\nlet find_all p =\n let rec find accu = function\n | [] -> rev accu\n | x :: l -> if p x then find (x :: accu) l else find accu l in\n find []\n\nlet filter = find_all\n\nlet partition p l =\n let rec part yes no = function\n | [] -> (rev yes, rev no)\n | x :: l -> if p x then part (x :: yes) no l else part yes (x :: no) l in\n part [] [] l\n\nlet rec split = function\n [] -> ([], [])\n | (x,y)::l ->\n let (rx, ry) = split l in (x::rx, y::ry)\n\nlet rec combine l1 l2 =\n match (l1, l2) with\n ([], []) -> []\n | (a1::l1, a2::l2) -> (a1, a2) :: combine l1 l2\n | (_, _) -> invalid_arg \"List.combine\"\n\n(** sorting *)\n\nlet rec merge cmp l1 l2 =\n match l1, l2 with\n | [], l2 -> l2\n | l1, [] -> l1\n | h1 :: t1, h2 :: t2 ->\n if cmp h1 h2 <= 0\n then h1 :: merge cmp t1 l2\n else h2 :: merge cmp l1 t2\n;;\n\nlet rec chop k l =\n if k = 0 then l else begin\n match l with\n | x::t -> chop (k-1) t\n | _ -> assert false\n end\n;;\n\nlet stable_sort cmp l =\n let rec rev_merge l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n if cmp h1 h2 <= 0\n then rev_merge t1 l2 (h1::accu)\n else rev_merge l1 t2 (h2::accu)\n in\n let rec rev_merge_rev l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n if cmp h1 h2 > 0\n then rev_merge_rev t1 l2 (h1::accu)\n else rev_merge_rev l1 t2 (h2::accu)\n in\n let rec sort n l =\n match n, l with\n | 2, x1 :: x2 :: _ ->\n if cmp x1 x2 <= 0 then [x1; x2] else [x2; x1]\n | 3, x1 :: x2 :: x3 :: _ ->\n if cmp x1 x2 <= 0 then begin\n if cmp x2 x3 <= 0 then [x1; x2; x3]\n else if cmp x1 x3 <= 0 then [x1; x3; x2]\n else [x3; x1; x2]\n end else begin\n if cmp x1 x3 <= 0 then [x2; x1; x3]\n else if cmp x2 x3 <= 0 then [x2; x3; x1]\n else [x3; x2; x1]\n end\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let l2 = chop n1 l in\n let s1 = rev_sort n1 l in\n let s2 = rev_sort n2 l2 in\n rev_merge_rev s1 s2 []\n and rev_sort n l =\n match n, l with\n | 2, x1 :: x2 :: _ ->\n if cmp x1 x2 > 0 then [x1; x2] else [x2; x1]\n | 3, x1 :: x2 :: x3 :: _ ->\n if cmp x1 x2 > 0 then begin\n if cmp x2 x3 > 0 then [x1; x2; x3]\n else if cmp x1 x3 > 0 then [x1; x3; x2]\n else [x3; x1; x2]\n end else begin\n if cmp x1 x3 > 0 then [x2; x1; x3]\n else if cmp x2 x3 > 0 then [x2; x3; x1]\n else [x3; x2; x1]\n end\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let l2 = chop n1 l in\n let s1 = sort n1 l in\n let s2 = sort n2 l2 in\n rev_merge s1 s2 []\n in\n let len = length l in\n if len < 2 then l else sort len l\n;;\n\nlet sort = stable_sort;;\nlet fast_sort = stable_sort;;\n\n(* Note: on a list of length between about 100000 (depending on the minor\n heap size and the type of the list) and Sys.max_array_size, it is\n actually faster to use the following, but it might also use more memory\n because the argument list cannot be deallocated incrementally.\n\n Also, there seems to be a bug in this code or in the\n implementation of obj_truncate.\n\nexternal obj_truncate : 'a array -> int -> unit = \"caml_obj_truncate\"\n\nlet array_to_list_in_place a =\n let l = Array.length a in\n let rec loop accu n p =\n if p <= 0 then accu else begin\n if p = n then begin\n obj_truncate a p;\n loop (a.(p-1) :: accu) (n-1000) (p-1)\n end else begin\n loop (a.(p-1) :: accu) n (p-1)\n end\n end\n in\n loop [] (l-1000) l\n;;\n\nlet stable_sort cmp l =\n let a = Array.of_list l in\n Array.stable_sort cmp a;\n array_to_list_in_place a\n;;\n*)\n\n\n(** sorting + removing duplicates *)\n\nlet sort_uniq cmp l =\n let rec rev_merge l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n let c = cmp h1 h2 in\n if c = 0 then rev_merge t1 t2 (h1::accu)\n else if c < 0\n then rev_merge t1 l2 (h1::accu)\n else rev_merge l1 t2 (h2::accu)\n in\n let rec rev_merge_rev l1 l2 accu =\n match l1, l2 with\n | [], l2 -> rev_append l2 accu\n | l1, [] -> rev_append l1 accu\n | h1::t1, h2::t2 ->\n let c = cmp h1 h2 in\n if c = 0 then rev_merge_rev t1 t2 (h1::accu)\n else if c > 0\n then rev_merge_rev t1 l2 (h1::accu)\n else rev_merge_rev l1 t2 (h2::accu)\n in\n let rec sort n l =\n match n, l with\n | 2, x1 :: x2 :: _ ->\n let c = cmp x1 x2 in\n if c = 0 then [x1]\n else if c < 0 then [x1; x2] else [x2; x1]\n | 3, x1 :: x2 :: x3 :: _ ->\n let c = cmp x1 x2 in\n if c = 0 then begin\n let c = cmp x2 x3 in\n if c = 0 then [x2]\n else if c < 0 then [x2; x3] else [x3; x2]\n end else if c < 0 then begin\n let c = cmp x2 x3 in\n if c = 0 then [x1; x2]\n else if c < 0 then [x1; x2; x3]\n else let c = cmp x1 x3 in\n if c = 0 then [x1; x2]\n else if c < 0 then [x1; x3; x2]\n else [x3; x1; x2]\n end else begin\n let c = cmp x1 x3 in\n if c = 0 then [x2; x1]\n else if c < 0 then [x2; x1; x3]\n else let c = cmp x2 x3 in\n if c = 0 then [x2; x1]\n else if c < 0 then [x2; x3; x1]\n else [x3; x2; x1]\n end\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let l2 = chop n1 l in\n let s1 = rev_sort n1 l in\n let s2 = rev_sort n2 l2 in\n rev_merge_rev s1 s2 []\n and rev_sort n l =\n match n, l with\n | 2, x1 :: x2 :: _ ->\n let c = cmp x1 x2 in\n if c = 0 then [x1]\n else if c > 0 then [x1; x2] else [x2; x1]\n | 3, x1 :: x2 :: x3 :: _ ->\n let c = cmp x1 x2 in\n if c = 0 then begin\n let c = cmp x2 x3 in\n if c = 0 then [x2]\n else if c > 0 then [x2; x3] else [x3; x2]\n end else if c > 0 then begin\n let c = cmp x2 x3 in\n if c = 0 then [x1; x2]\n else if c > 0 then [x1; x2; x3]\n else let c = cmp x1 x3 in\n if c = 0 then [x1; x2]\n else if c > 0 then [x1; x3; x2]\n else [x3; x1; x2]\n end else begin\n let c = cmp x1 x3 in\n if c = 0 then [x2; x1]\n else if c > 0 then [x2; x1; x3]\n else let c = cmp x2 x3 in\n if c = 0 then [x2; x1]\n else if c > 0 then [x2; x3; x1]\n else [x3; x2; x1]\n end\n | n, l ->\n let n1 = n asr 1 in\n let n2 = n - n1 in\n let l2 = chop n1 l in\n let s1 = sort n1 l in\n let s2 = sort n2 l2 in\n rev_merge s1 s2 []\n in\n let len = length l in\n if len < 2 then l else sort len l\n;;\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* Character operations *)\n\nexternal code: char -> int = \"%identity\"\nexternal unsafe_chr: int -> char = \"%identity\"\n\nlet chr n =\n if n < 0 || n > 255 then invalid_arg \"Char.chr\" else unsafe_chr n\n\nexternal is_printable: char -> bool = \"caml_is_printable\"\n\nexternal string_create: int -> string = \"caml_create_string\"\nexternal string_unsafe_get : string -> int -> char = \"%string_unsafe_get\"\nexternal string_unsafe_set : string -> int -> char -> unit\n = \"%string_unsafe_set\"\n\nlet escaped = function\n | '\\'' -> \"\\\\'\"\n | '\\\\' -> \"\\\\\\\\\"\n | '\\n' -> \"\\\\n\"\n | '\\t' -> \"\\\\t\"\n | '\\r' -> \"\\\\r\"\n | '\\b' -> \"\\\\b\"\n | c ->\n if is_printable c then begin\n let s = string_create 1 in\n string_unsafe_set s 0 c;\n s\n end else begin\n let n = code c in\n let s = string_create 4 in\n string_unsafe_set s 0 '\\\\';\n string_unsafe_set s 1 (unsafe_chr (48 + n / 100));\n string_unsafe_set s 2 (unsafe_chr (48 + (n / 10) mod 10));\n string_unsafe_set s 3 (unsafe_chr (48 + n mod 10));\n s\n end\n\nlet lowercase c =\n if (c >= 'A' && c <= 'Z')\n || (c >= '\\192' && c <= '\\214')\n || (c >= '\\216' && c <= '\\222')\n then unsafe_chr(code c + 32)\n else c\n\nlet uppercase c =\n if (c >= 'a' && c <= 'z')\n || (c >= '\\224' && c <= '\\246')\n || (c >= '\\248' && c <= '\\254')\n then unsafe_chr(code c - 32)\n else c\n\ntype t = char\n\nlet compare c1 c2 = code c1 - code c2\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* Byte sequence operations *)\n\nexternal length : bytes -> int = \"%string_length\"\nexternal string_length : string -> int = \"%string_length\"\nexternal get : bytes -> int -> char = \"%string_safe_get\"\nexternal set : bytes -> int -> char -> unit = \"%string_safe_set\"\nexternal create : int -> bytes = \"caml_create_string\"\nexternal unsafe_get : bytes -> int -> char = \"%string_unsafe_get\"\nexternal unsafe_set : bytes -> int -> char -> unit = \"%string_unsafe_set\"\nexternal unsafe_fill : bytes -> int -> int -> char -> unit\n = \"caml_fill_string\" \"noalloc\"\nexternal unsafe_to_string : bytes -> string = \"%identity\"\nexternal unsafe_of_string : string -> bytes = \"%identity\"\n\nexternal unsafe_blit : bytes -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" \"noalloc\"\nexternal unsafe_blit_string : string -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" \"noalloc\"\n\nlet make n c =\n let s = create n in\n unsafe_fill s 0 n c;\n s\n\nlet init n f =\n let s = create n in\n for i = 0 to n - 1 do\n unsafe_set s i (f i)\n done;\n s\n\nlet empty = create 0;;\n\nlet copy s =\n let len = length s in\n let r = create len in\n unsafe_blit s 0 r 0 len;\n r\n\nlet to_string b = unsafe_to_string (copy b)\nlet of_string s = copy (unsafe_of_string s)\n\nlet sub s ofs len =\n if ofs < 0 || len < 0 || ofs > length s - len\n then invalid_arg \"String.sub / Bytes.sub\"\n else begin\n let r = create len in\n unsafe_blit s ofs r 0 len;\n r\n end\n\nlet sub_string b ofs len = unsafe_to_string (sub b ofs len)\n\nlet extend s left right =\n let len = length s + left + right in\n let r = create len in\n let (srcoff, dstoff) = if left < 0 then -left, 0 else 0, left in\n let cpylen = min (length s - srcoff) (len - dstoff) in\n if cpylen > 0 then unsafe_blit s srcoff r dstoff cpylen;\n r\n\nlet fill s ofs len c =\n if ofs < 0 || len < 0 || ofs > length s - len\n then invalid_arg \"String.fill / Bytes.fill\"\n else unsafe_fill s ofs len c\n\nlet blit s1 ofs1 s2 ofs2 len =\n if len < 0 || ofs1 < 0 || ofs1 > length s1 - len\n || ofs2 < 0 || ofs2 > length s2 - len\n then invalid_arg \"Bytes.blit\"\n else unsafe_blit s1 ofs1 s2 ofs2 len\n\nlet blit_string s1 ofs1 s2 ofs2 len =\n if len < 0 || ofs1 < 0 || ofs1 > string_length s1 - len\n || ofs2 < 0 || ofs2 > length s2 - len\n then invalid_arg \"String.blit / Bytes.blit_string\"\n else unsafe_blit_string s1 ofs1 s2 ofs2 len\n\nlet iter f a =\n for i = 0 to length a - 1 do f(unsafe_get a i) done\n\nlet iteri f a =\n for i = 0 to length a - 1 do f i (unsafe_get a i) done\n\nlet concat sep l =\n match l with\n [] -> empty\n | hd :: tl ->\n let num = ref 0 and len = ref 0 in\n List.iter (fun s -> incr num; len := !len + length s) l;\n let r = create (!len + length sep * (!num - 1)) in\n unsafe_blit hd 0 r 0 (length hd);\n let pos = ref(length hd) in\n List.iter\n (fun s ->\n unsafe_blit sep 0 r !pos (length sep);\n pos := !pos + length sep;\n unsafe_blit s 0 r !pos (length s);\n pos := !pos + length s)\n tl;\n r\n\nlet cat s1 s2 =\n let l1 = length s1 in\n let l2 = length s2 in\n let r = create (l1 + l2) in\n unsafe_blit s1 0 r 0 l1;\n unsafe_blit s2 0 r l1 l2;\n r\n;;\n\nexternal is_printable: char -> bool = \"caml_is_printable\"\nexternal char_code: char -> int = \"%identity\"\nexternal char_chr: int -> char = \"%identity\"\n\nlet is_space = function\n | ' ' | '\\012' | '\\n' | '\\r' | '\\t' -> true\n | _ -> false\n\nlet trim s =\n let len = length s in\n let i = ref 0 in\n while !i < len && is_space (unsafe_get s !i) do\n incr i\n done;\n let j = ref (len - 1) in\n while !j >= !i && is_space (unsafe_get s !j) do\n decr j\n done;\n if !j >= !i then\n sub s !i (!j - !i + 1)\n else\n empty\n\nlet escaped s =\n let n = ref 0 in\n for i = 0 to length s - 1 do\n n := !n +\n (match unsafe_get s i with\n | '\"' | '\\\\' | '\\n' | '\\t' | '\\r' | '\\b' -> 2\n | c -> if is_printable c then 1 else 4)\n done;\n if !n = length s then copy s else begin\n let s' = create !n in\n n := 0;\n for i = 0 to length s - 1 do\n begin match unsafe_get s i with\n | ('\"' | '\\\\') as c ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n c\n | '\\n' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 'n'\n | '\\t' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 't'\n | '\\r' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 'r'\n | '\\b' ->\n unsafe_set s' !n '\\\\'; incr n; unsafe_set s' !n 'b'\n | c ->\n if is_printable c then\n unsafe_set s' !n c\n else begin\n let a = char_code c in\n unsafe_set s' !n '\\\\';\n incr n;\n unsafe_set s' !n (char_chr (48 + a / 100));\n incr n;\n unsafe_set s' !n (char_chr (48 + (a / 10) mod 10));\n incr n;\n unsafe_set s' !n (char_chr (48 + a mod 10))\n end\n end;\n incr n\n done;\n s'\n end\n\nlet map f s =\n let l = length s in\n if l = 0 then s else begin\n let r = create l in\n for i = 0 to l - 1 do unsafe_set r i (f (unsafe_get s i)) done;\n r\n end\n\nlet mapi f s =\n let l = length s in\n if l = 0 then s else begin\n let r = create l in\n for i = 0 to l - 1 do unsafe_set r i (f i (unsafe_get s i)) done;\n r\n end\n\nlet uppercase s = map Char.uppercase s\nlet lowercase s = map Char.lowercase s\n\nlet apply1 f s =\n if length s = 0 then s else begin\n let r = copy s in\n unsafe_set r 0 (f(unsafe_get s 0));\n r\n end\n\nlet capitalize s = apply1 Char.uppercase s\nlet uncapitalize s = apply1 Char.lowercase s\n\nlet rec index_rec s lim i c =\n if i >= lim then raise Not_found else\n if unsafe_get s i = c then i else index_rec s lim (i + 1) c;;\n\nlet index s c = index_rec s (length s) 0 c;;\n\nlet index_from s i c =\n let l = length s in\n if i < 0 || i > l then invalid_arg \"String.index_from / Bytes.index_from\" else\n index_rec s l i c;;\n\nlet rec rindex_rec s i c =\n if i < 0 then raise Not_found else\n if unsafe_get s i = c then i else rindex_rec s (i - 1) c;;\n\nlet rindex s c = rindex_rec s (length s - 1) c;;\n\nlet rindex_from s i c =\n if i < -1 || i >= length s then\n invalid_arg \"String.rindex_from / Bytes.rindex_from\"\n else\n rindex_rec s i c\n;;\n\nlet contains_from s i c =\n let l = length s in\n if i < 0 || i > l then\n invalid_arg \"String.contains_from / Bytes.contains_from\"\n else\n try ignore (index_rec s l i c); true with Not_found -> false\n;;\n\nlet contains s c = contains_from s 0 c;;\n\nlet rcontains_from s i c =\n if i < 0 || i >= length s then\n invalid_arg \"String.rcontains_from / Bytes.rcontains_from\"\n else\n try ignore (rindex_rec s i c); true with Not_found -> false\n;;\n\ntype t = bytes\n\nlet compare (x: t) (y: t) = Pervasives.compare x y\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Gallium, INRIA Rocquencourt *)\n(* *)\n(* Copyright 2014 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* String operations, based on byte sequence operations *)\n\nexternal length : string -> int = \"%string_length\"\nexternal get : string -> int -> char = \"%string_safe_get\"\nexternal set : bytes -> int -> char -> unit = \"%string_safe_set\"\nexternal create : int -> bytes = \"caml_create_string\"\nexternal unsafe_get : string -> int -> char = \"%string_unsafe_get\"\nexternal unsafe_set : bytes -> int -> char -> unit = \"%string_unsafe_set\"\nexternal unsafe_blit : string -> int -> bytes -> int -> int -> unit\n = \"caml_blit_string\" \"noalloc\"\nexternal unsafe_fill : bytes -> int -> int -> char -> unit\n = \"caml_fill_string\" \"noalloc\"\n\nmodule B = Bytes\n\nlet bts = B.unsafe_to_string\nlet bos = B.unsafe_of_string\n\nlet make n c =\n B.make n c |> bts\nlet init n f =\n B.init n f |> bts\nlet copy s =\n B.copy (bos s) |> bts\nlet sub s ofs len =\n B.sub (bos s) ofs len |> bts\nlet fill =\n B.fill\nlet blit =\n B.blit_string\n\nlet concat sep l =\n match l with\n | [] -> \"\"\n | hd :: tl ->\n let num = ref 0 and len = ref 0 in\n List.iter (fun s -> incr num; len := !len + length s) l;\n let r = B.create (!len + length sep * (!num - 1)) in\n unsafe_blit hd 0 r 0 (length hd);\n let pos = ref(length hd) in\n List.iter\n (fun s ->\n unsafe_blit sep 0 r !pos (length sep);\n pos := !pos + length sep;\n unsafe_blit s 0 r !pos (length s);\n pos := !pos + length s)\n tl;\n Bytes.unsafe_to_string r\n\nlet iter f s =\n B.iter f (bos s)\nlet iteri f s =\n B.iteri f (bos s)\nlet map f s =\n B.map f (bos s) |> bts\nlet mapi f s =\n B.mapi f (bos s) |> bts\n\n(* Beware: we cannot use B.trim or B.escape because they always make a\n copy, but String.mli spells out some cases where we are not allowed\n to make a copy. *)\n\nexternal is_printable: char -> bool = \"caml_is_printable\"\n\nlet is_space = function\n | ' ' | '\\012' | '\\n' | '\\r' | '\\t' -> true\n | _ -> false\n\nlet trim s =\n if s = \"\" then s\n else if is_space (unsafe_get s 0) || is_space (unsafe_get s (length s - 1))\n then bts (B.trim (bos s))\n else s\n\nlet escaped s =\n let rec needs_escape i =\n if i >= length s then false else\n match unsafe_get s i with\n | '\"' | '\\\\' | '\\n' | '\\t' | '\\r' | '\\b' -> true\n | c when is_printable c -> needs_escape (i+1)\n | _ -> true\n in\n if needs_escape 0 then\n bts (B.escaped (bos s))\n else\n s\n\nlet index s c =\n B.index (bos s) c\nlet rindex s c =\n B.rindex (bos s) c\nlet index_from s i c=\n B.index_from (bos s) i c\nlet rindex_from s i c =\n B.rindex_from (bos s) i c\nlet contains s c =\n B.contains (bos s) c\nlet contains_from s i c =\n B.contains_from (bos s) i c\nlet rcontains_from s i c =\n B.rcontains_from (bos s) i c\nlet uppercase s =\n B.uppercase (bos s) |> bts\nlet lowercase s =\n B.lowercase (bos s) |> bts\nlet capitalize s =\n B.capitalize (bos s) |> bts\nlet uncapitalize s =\n B.uncapitalize (bos s) |> bts\n\ntype t = string\n\nlet compare (x: t) (y: t) = Pervasives.compare x y\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* WARNING: sys.ml is generated from sys.mlp. DO NOT EDIT sys.ml or\n your changes will be lost.\n*)\n\n(* System interface *)\n\nexternal get_config: unit -> string * int * bool = \"caml_sys_get_config\"\nexternal get_argv: unit -> string * string array = \"caml_sys_get_argv\"\nexternal big_endian : unit -> bool = \"%big_endian\"\nexternal word_size : unit -> int = \"%word_size\"\nexternal unix : unit -> bool = \"%ostype_unix\"\nexternal win32 : unit -> bool = \"%ostype_win32\"\nexternal cygwin : unit -> bool = \"%ostype_cygwin\"\n\nlet (executable_name, argv) = get_argv()\nlet (os_type, _, _) = get_config()\nlet big_endian = big_endian ()\nlet word_size = word_size ()\nlet unix = unix ()\nlet win32 = win32 ()\nlet cygwin = cygwin ()\nlet max_array_length = (1 lsl (word_size - 10)) - 1;;\nlet max_string_length = word_size / 8 * max_array_length - 1;;\n\nexternal file_exists: string -> bool = \"caml_sys_file_exists\"\nexternal is_directory : string -> bool = \"caml_sys_is_directory\"\nexternal remove: string -> unit = \"caml_sys_remove\"\nexternal rename : string -> string -> unit = \"caml_sys_rename\"\nexternal getenv: string -> string = \"caml_sys_getenv\"\nexternal command: string -> int = \"caml_sys_system_command\"\nexternal time: unit -> float = \"caml_sys_time\"\nexternal chdir: string -> unit = \"caml_sys_chdir\"\nexternal getcwd: unit -> string = \"caml_sys_getcwd\"\nexternal readdir : string -> string array = \"caml_sys_read_directory\"\n\nlet interactive = ref false\n\ntype signal_behavior =\n Signal_default\n | Signal_ignore\n | Signal_handle of (int -> unit)\n\nexternal signal : int -> signal_behavior -> signal_behavior\n = \"caml_install_signal_handler\"\n\nlet set_signal sig_num sig_beh = ignore(signal sig_num sig_beh)\n\nlet sigabrt = -1\nlet sigalrm = -2\nlet sigfpe = -3\nlet sighup = -4\nlet sigill = -5\nlet sigint = -6\nlet sigkill = -7\nlet sigpipe = -8\nlet sigquit = -9\nlet sigsegv = -10\nlet sigterm = -11\nlet sigusr1 = -12\nlet sigusr2 = -13\nlet sigchld = -14\nlet sigcont = -15\nlet sigstop = -16\nlet sigtstp = -17\nlet sigttin = -18\nlet sigttou = -19\nlet sigvtalrm = -20\nlet sigprof = -21\n\nexception Break\n\nlet catch_break on =\n if on then\n set_signal sigint (Signal_handle(fun _ -> raise Break))\n else\n set_signal sigint Signal_default\n\n\n(* The version string is found in file ../VERSION *)\n\nlet ocaml_version = \"4.02.3\";;\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* The run-time library for lexers generated by camllex *)\n\ntype position = {\n pos_fname : string;\n pos_lnum : int;\n pos_bol : int;\n pos_cnum : int;\n}\n\nlet dummy_pos = {\n pos_fname = \"\";\n pos_lnum = 0;\n pos_bol = 0;\n pos_cnum = -1;\n}\n\ntype lexbuf =\n { refill_buff : lexbuf -> unit;\n mutable lex_buffer : bytes;\n mutable lex_buffer_len : int;\n mutable lex_abs_pos : int;\n mutable lex_start_pos : int;\n mutable lex_curr_pos : int;\n mutable lex_last_pos : int;\n mutable lex_last_action : int;\n mutable lex_eof_reached : bool;\n mutable lex_mem : int array;\n mutable lex_start_p : position;\n mutable lex_curr_p : position;\n }\n\ntype lex_tables =\n { lex_base: string;\n lex_backtrk: string;\n lex_default: string;\n lex_trans: string;\n lex_check: string;\n lex_base_code : string;\n lex_backtrk_code : string;\n lex_default_code : string;\n lex_trans_code : string;\n lex_check_code : string;\n lex_code: string;}\n\nexternal c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\nexternal c_new_engine : lex_tables -> int -> lexbuf -> int\n = \"caml_new_lex_engine\"\n\nlet engine tbl state buf =\n let result = c_engine tbl state buf in\n if result >= 0 then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n result\n;;\n\nlet new_engine tbl state buf =\n let result = c_new_engine tbl state buf in\n if result >= 0 then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n result\n;;\n\nlet lex_refill read_fun aux_buffer lexbuf =\n let read =\n read_fun aux_buffer (Bytes.length aux_buffer) in\n let n =\n if read > 0\n then read\n else (lexbuf.lex_eof_reached <- true; 0) in\n (* Current state of the buffer:\n <-------|---------------------|----------->\n | junk | valid data | junk |\n ^ ^ ^ ^\n 0 start_pos buffer_end Bytes.length buffer\n *)\n if lexbuf.lex_buffer_len + n > Bytes.length lexbuf.lex_buffer then begin\n (* There is not enough space at the end of the buffer *)\n if lexbuf.lex_buffer_len - lexbuf.lex_start_pos + n\n <= Bytes.length lexbuf.lex_buffer\n then begin\n (* But there is enough space if we reclaim the junk at the beginning\n of the buffer *)\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos\n lexbuf.lex_buffer 0\n (lexbuf.lex_buffer_len - lexbuf.lex_start_pos)\n end else begin\n (* We must grow the buffer. Doubling its size will provide enough\n space since n <= String.length aux_buffer <= String.length buffer.\n Watch out for string length overflow, though. *)\n let newlen =\n min (2 * Bytes.length lexbuf.lex_buffer) Sys.max_string_length in\n if lexbuf.lex_buffer_len - lexbuf.lex_start_pos + n > newlen\n then failwith \"Lexing.lex_refill: cannot grow buffer\";\n let newbuf = Bytes.create newlen in\n (* Copy the valid data to the beginning of the new buffer *)\n Bytes.blit lexbuf.lex_buffer lexbuf.lex_start_pos\n newbuf 0\n (lexbuf.lex_buffer_len - lexbuf.lex_start_pos);\n lexbuf.lex_buffer <- newbuf\n end;\n (* Reallocation or not, we have shifted the data left by\n start_pos characters; update the positions *)\n let s = lexbuf.lex_start_pos in\n lexbuf.lex_abs_pos <- lexbuf.lex_abs_pos + s;\n lexbuf.lex_curr_pos <- lexbuf.lex_curr_pos - s;\n lexbuf.lex_start_pos <- 0;\n lexbuf.lex_last_pos <- lexbuf.lex_last_pos - s;\n lexbuf.lex_buffer_len <- lexbuf.lex_buffer_len - s ;\n let t = lexbuf.lex_mem in\n for i = 0 to Array.length t-1 do\n let v = t.(i) in\n if v >= 0 then\n t.(i) <- v-s\n done\n end;\n (* There is now enough space at the end of the buffer *)\n Bytes.blit aux_buffer 0 lexbuf.lex_buffer lexbuf.lex_buffer_len n;\n lexbuf.lex_buffer_len <- lexbuf.lex_buffer_len + n\n\nlet zero_pos = {\n pos_fname = \"\";\n pos_lnum = 1;\n pos_bol = 0;\n pos_cnum = 0;\n};;\n\nlet from_function f =\n { refill_buff = lex_refill f (Bytes.create 512);\n lex_buffer = Bytes.create 1024;\n lex_buffer_len = 0;\n lex_abs_pos = 0;\n lex_start_pos = 0;\n lex_curr_pos = 0;\n lex_last_pos = 0;\n lex_last_action = 0;\n lex_mem = [||];\n lex_eof_reached = false;\n lex_start_p = zero_pos;\n lex_curr_p = zero_pos;\n }\n\nlet from_channel ic =\n from_function (fun buf n -> input ic buf 0 n)\n\nlet from_string s =\n { refill_buff = (fun lexbuf -> lexbuf.lex_eof_reached <- true);\n lex_buffer = Bytes.of_string s; (* have to make a copy for compatibility\n with unsafe-string mode *)\n lex_buffer_len = String.length s;\n lex_abs_pos = 0;\n lex_start_pos = 0;\n lex_curr_pos = 0;\n lex_last_pos = 0;\n lex_last_action = 0;\n lex_mem = [||];\n lex_eof_reached = true;\n lex_start_p = zero_pos;\n lex_curr_p = zero_pos;\n }\n\nlet lexeme lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bytes.sub_string lexbuf.lex_buffer lexbuf.lex_start_pos len\n\nlet sub_lexeme lexbuf i1 i2 =\n let len = i2-i1 in\n Bytes.sub_string lexbuf.lex_buffer i1 len\n\nlet sub_lexeme_opt lexbuf i1 i2 =\n if i1 >= 0 then begin\n let len = i2-i1 in\n Some (Bytes.sub_string lexbuf.lex_buffer i1 len)\n end else begin\n None\n end\n\nlet sub_lexeme_char lexbuf i = Bytes.get lexbuf.lex_buffer i\n\nlet sub_lexeme_char_opt lexbuf i =\n if i >= 0 then\n Some (Bytes.get lexbuf.lex_buffer i)\n else\n None\n\n\nlet lexeme_char lexbuf i =\n Bytes.get lexbuf.lex_buffer (lexbuf.lex_start_pos + i)\n\nlet lexeme_start lexbuf = lexbuf.lex_start_p.pos_cnum;;\nlet lexeme_end lexbuf = lexbuf.lex_curr_p.pos_cnum;;\n\nlet lexeme_start_p lexbuf = lexbuf.lex_start_p;;\nlet lexeme_end_p lexbuf = lexbuf.lex_curr_p;;\n\nlet new_line lexbuf =\n let lcp = lexbuf.lex_curr_p in\n lexbuf.lex_curr_p <- { lcp with\n pos_lnum = lcp.pos_lnum + 1;\n pos_bol = lcp.pos_cnum;\n }\n;;\n\n\n(* Discard data left in lexer buffer. *)\n\nlet flush_input lb =\n lb.lex_curr_pos <- 0;\n lb.lex_abs_pos <- 0;\n lb.lex_curr_p <- {lb.lex_curr_p with pos_cnum = 0};\n lb.lex_buffer_len <- 0;\n;;\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1997 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* Internals of forcing lazy values. *)\n\nexception Undefined;;\n\nlet raise_undefined = Obj.repr (fun () -> raise Undefined);;\n\n(* Assume [blk] is a block with tag lazy *)\nlet force_lazy_block (blk : 'arg lazy_t) =\n let closure = (Obj.obj (Obj.field (Obj.repr blk) 0) : unit -> 'arg) in\n Obj.set_field (Obj.repr blk) 0 raise_undefined;\n try\n let result = closure () in\n (* do set_field BEFORE set_tag *)\n Obj.set_field (Obj.repr blk) 0 (Obj.repr result);\n Obj.set_tag (Obj.repr blk) Obj.forward_tag;\n result\n with e ->\n Obj.set_field (Obj.repr blk) 0 (Obj.repr (fun () -> raise e));\n raise e\n;;\n\n(* Assume [blk] is a block with tag lazy *)\nlet force_val_lazy_block (blk : 'arg lazy_t) =\n let closure = (Obj.obj (Obj.field (Obj.repr blk) 0) : unit -> 'arg) in\n Obj.set_field (Obj.repr blk) 0 raise_undefined;\n let result = closure () in\n (* do set_field BEFORE set_tag *)\n Obj.set_field (Obj.repr blk) 0 (Obj.repr result);\n Obj.set_tag (Obj.repr blk) (Obj.forward_tag);\n result\n;;\n\n(* [force] is not used, since [Lazy.force] is declared as a primitive\n whose code inlines the tag tests of its argument. This function is\n here for the sake of completeness, and for debugging purpose. *)\n\nlet force (lzv : 'arg lazy_t) =\n let x = Obj.repr lzv in\n let t = Obj.tag x in\n if t = Obj.forward_tag then (Obj.obj (Obj.field x 0) : 'arg) else\n if t <> Obj.lazy_tag then (Obj.obj x : 'arg)\n else force_lazy_block lzv\n;;\n\nlet force_val (lzv : 'arg lazy_t) =\n let x = Obj.repr lzv in\n let t = Obj.tag x in\n if t = Obj.forward_tag then (Obj.obj (Obj.field x 0) : 'arg) else\n if t <> Obj.lazy_tag then (Obj.obj x : 'arg)\n else force_val_lazy_block lzv\n;;\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Weis and Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1999 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* Extensible buffers *)\n\ntype t =\n {mutable buffer : bytes;\n mutable position : int;\n mutable length : int;\n initial_buffer : bytes}\n\nlet create n =\n let n = if n < 1 then 1 else n in\n let n = if n > Sys.max_string_length then Sys.max_string_length else n in\n let s = Bytes.create n in\n {buffer = s; position = 0; length = n; initial_buffer = s}\n\nlet contents b = Bytes.sub_string b.buffer 0 b.position\nlet to_bytes b = Bytes.sub b.buffer 0 b.position\n\nlet sub b ofs len =\n if ofs < 0 || len < 0 || ofs > b.position - len\n then invalid_arg \"Buffer.sub\"\n else Bytes.sub_string b.buffer ofs len\n;;\n\nlet blit src srcoff dst dstoff len =\n if len < 0 || srcoff < 0 || srcoff > src.position - len\n || dstoff < 0 || dstoff > (Bytes.length dst) - len\n then invalid_arg \"Buffer.blit\"\n else\n Bytes.blit src.buffer srcoff dst dstoff len\n;;\n\nlet nth b ofs =\n if ofs < 0 || ofs >= b.position then\n invalid_arg \"Buffer.nth\"\n else Bytes.unsafe_get b.buffer ofs\n;;\n\nlet length b = b.position\n\nlet clear b = b.position <- 0\n\nlet reset b =\n b.position <- 0; b.buffer <- b.initial_buffer;\n b.length <- Bytes.length b.buffer\n\nlet resize b more =\n let len = b.length in\n let new_len = ref len in\n while b.position + more > !new_len do new_len := 2 * !new_len done;\n if !new_len > Sys.max_string_length then begin\n if b.position + more <= Sys.max_string_length\n then new_len := Sys.max_string_length\n else failwith \"Buffer.add: cannot grow buffer\"\n end;\n let new_buffer = Bytes.create !new_len in\n Bytes.blit b.buffer 0 new_buffer 0 b.position;\n b.buffer <- new_buffer;\n b.length <- !new_len\n\nlet add_char b c =\n let pos = b.position in\n if pos >= b.length then resize b 1;\n Bytes.unsafe_set b.buffer pos c;\n b.position <- pos + 1\n\nlet add_substring b s offset len =\n if offset < 0 || len < 0 || offset + len > String.length s\n then invalid_arg \"Buffer.add_substring/add_subbytes\";\n let new_position = b.position + len in\n if new_position > b.length then resize b len;\n Bytes.blit_string s offset b.buffer b.position len;\n b.position <- new_position\n\nlet add_subbytes b s offset len =\n add_substring b (Bytes.unsafe_to_string s) offset len\n\nlet add_string b s =\n let len = String.length s in\n let new_position = b.position + len in\n if new_position > b.length then resize b len;\n Bytes.blit_string s 0 b.buffer b.position len;\n b.position <- new_position\n\nlet add_bytes b s = add_string b (Bytes.unsafe_to_string s)\n\nlet add_buffer b bs =\n add_subbytes b bs.buffer 0 bs.position\n\nlet add_channel b ic len =\n if len < 0 || len > Sys.max_string_length then (* PR#5004 *)\n invalid_arg \"Buffer.add_channel\";\n if b.position + len > b.length then resize b len;\n really_input ic b.buffer b.position len;\n b.position <- b.position + len\n\nlet output_buffer oc b =\n output oc b.buffer 0 b.position\n\nlet closing = function\n | '(' -> ')'\n | '{' -> '}'\n | _ -> assert false;;\n\n(* opening and closing: open and close characters, typically ( and )\n k: balance of opening and closing chars\n s: the string where we are searching\n start: the index where we start the search. *)\nlet advance_to_closing opening closing k s start =\n let rec advance k i lim =\n if i >= lim then raise Not_found else\n if s.[i] = opening then advance (k + 1) (i + 1) lim else\n if s.[i] = closing then\n if k = 0 then i else advance (k - 1) (i + 1) lim\n else advance k (i + 1) lim in\n advance k start (String.length s);;\n\nlet advance_to_non_alpha s start =\n let rec advance i lim =\n if i >= lim then lim else\n match s.[i] with\n | 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' -> advance (i + 1) lim\n | _ -> i in\n advance start (String.length s);;\n\n(* We are just at the beginning of an ident in s, starting at start. *)\nlet find_ident s start lim =\n if start >= lim then raise Not_found else\n match s.[start] with\n (* Parenthesized ident ? *)\n | '(' | '{' as c ->\n let new_start = start + 1 in\n let stop = advance_to_closing c (closing c) 0 s new_start in\n String.sub s new_start (stop - start - 1), stop + 1\n (* Regular ident *)\n | _ ->\n let stop = advance_to_non_alpha s (start + 1) in\n String.sub s start (stop - start), stop;;\n\n(* Substitute $ident, $(ident), or ${ident} in s,\n according to the function mapping f. *)\nlet add_substitute b f s =\n let lim = String.length s in\n let rec subst previous i =\n if i < lim then begin\n match s.[i] with\n | '$' as current when previous = '\\\\' ->\n add_char b current;\n subst ' ' (i + 1)\n | '$' ->\n let j = i + 1 in\n let ident, next_i = find_ident s j lim in\n add_string b (f ident);\n subst ' ' next_i\n | current when previous == '\\\\' ->\n add_char b '\\\\';\n add_char b current;\n subst ' ' (i + 1)\n | '\\\\' as current ->\n subst current (i + 1)\n | current ->\n add_char b current;\n subst current (i + 1)\n end else\n if previous = '\\\\' then add_char b previous in\n subst ' ' 0;;\n", "open CamlinternalFormatBasics\n\n(******************************************************************************)\n (* Tools to manipulate scanning set of chars (see %[...]) *)\n\ntype mutable_char_set = bytes\n\n(* Create a fresh, empty, mutable char set. *)\nlet create_char_set () = Bytes.make 32 '\\000'\n\n(* Add a char in a mutable char set. *)\nlet add_in_char_set char_set c =\n let ind = int_of_char c in\n let str_ind = ind lsr 3 and mask = 1 lsl (ind land 0b111) in\n Bytes.set char_set str_ind\n (char_of_int (int_of_char (Bytes.get char_set str_ind) lor mask))\n\nlet freeze_char_set char_set =\n Bytes.to_string char_set\n\n(* Compute the complement of a char set. *)\nlet rev_char_set char_set =\n let char_set' = create_char_set () in\n for i = 0 to 31 do\n Bytes.set char_set' i\n (char_of_int (int_of_char (String.get char_set i) lxor 0xFF));\n done;\n Bytes.unsafe_to_string char_set'\n\n(* Return true if a `c' is in `char_set'. *)\nlet is_in_char_set char_set c =\n let ind = int_of_char c in\n let str_ind = ind lsr 3 and mask = 1 lsl (ind land 0b111) in\n (int_of_char (String.get char_set str_ind) land mask) <> 0\n\n\n(******************************************************************************)\n (* Ignored param conversion *)\n\n(* GADT used to abstract an existential type parameter. *)\n(* See param_format_of_ignored_format. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) param_format_ebb = Param_format_EBB :\n ('x -> 'a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('a, 'b, 'c, 'd, 'e, 'f) param_format_ebb\n\n(* Compute a padding associated to a pad_option (see \"%_42d\"). *)\nlet pad_of_pad_opt pad_opt = match pad_opt with\n | None -> No_padding\n | Some width -> Lit_padding (Right, width)\n\n(* Compute a precision associated to a prec_option (see \"%_.42f\"). *)\nlet prec_of_prec_opt prec_opt = match prec_opt with\n | None -> No_precision\n | Some ndec -> Lit_precision ndec\n\n(* Turn an ignored param into its equivalent not-ignored format node. *)\n(* Used for format pretty-printing and Scanf. *)\nlet param_format_of_ignored_format : type a b c d e f x y .\n (a, b, c, d, y, x) ignored -> (x, b, c, y, e, f) fmt ->\n (a, b, c, d, e, f) param_format_ebb =\nfun ign fmt -> match ign with\n | Ignored_char ->\n Param_format_EBB (Char fmt)\n | Ignored_caml_char ->\n Param_format_EBB (Caml_char fmt)\n | Ignored_string pad_opt ->\n Param_format_EBB (String (pad_of_pad_opt pad_opt, fmt))\n | Ignored_caml_string pad_opt ->\n Param_format_EBB (Caml_string (pad_of_pad_opt pad_opt, fmt))\n | Ignored_int (iconv, pad_opt) ->\n Param_format_EBB (Int (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_int32 (iconv, pad_opt) ->\n Param_format_EBB\n (Int32 (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_nativeint (iconv, pad_opt) ->\n Param_format_EBB\n (Nativeint (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_int64 (iconv, pad_opt) ->\n Param_format_EBB\n (Int64 (iconv, pad_of_pad_opt pad_opt, No_precision, fmt))\n | Ignored_float (pad_opt, prec_opt) ->\n Param_format_EBB\n (Float (Float_f, pad_of_pad_opt pad_opt, prec_of_prec_opt prec_opt, fmt))\n | Ignored_bool ->\n Param_format_EBB (Bool fmt)\n | Ignored_format_arg (pad_opt, fmtty) ->\n Param_format_EBB (Format_arg (pad_opt, fmtty, fmt))\n | Ignored_format_subst (pad_opt, fmtty) ->\n Param_format_EBB\n (Format_subst (pad_opt, fmtty, fmt))\n | Ignored_reader ->\n Param_format_EBB (Reader fmt)\n | Ignored_scan_char_set (width_opt, char_set) ->\n Param_format_EBB (Scan_char_set (width_opt, char_set, fmt))\n | Ignored_scan_get_counter counter ->\n Param_format_EBB (Scan_get_counter (counter, fmt))\n | Ignored_scan_next_char ->\n Param_format_EBB (Scan_next_char fmt)\n\n\n(******************************************************************************)\n (* Types *)\n\ntype ('b, 'c) acc_formatting_gen =\n | Acc_open_tag of ('b, 'c) acc\n | Acc_open_box of ('b, 'c) acc\n\n(* Reversed list of printing atoms. *)\n(* Used to accumulate printf arguments. *)\nand ('b, 'c) acc =\n | Acc_formatting_lit of ('b, 'c) acc * formatting_lit (* Special fmtting (box) *)\n | Acc_formatting_gen of ('b, 'c) acc * ('b, 'c) acc_formatting_gen (* Special fmtting (box) *)\n | Acc_string_literal of ('b, 'c) acc * string (* Literal string *)\n | Acc_char_literal of ('b, 'c) acc * char (* Literal char *)\n | Acc_data_string of ('b, 'c) acc * string (* Generated string *)\n | Acc_data_char of ('b, 'c) acc * char (* Generated char *)\n | Acc_delay of ('b, 'c) acc * ('b -> 'c) (* Delayed printing (%a, %t) *)\n | Acc_flush of ('b, 'c) acc (* Flush *)\n | Acc_invalid_arg of ('b, 'c) acc * string (* Raise Invalid_argument msg *)\n | End_of_acc\n\n(* List of heterogeneous values. *)\n(* Used to accumulate scanf callback arguments. *)\ntype ('a, 'b) heter_list =\n | Cons : 'c * ('a, 'b) heter_list -> ('c -> 'a, 'b) heter_list\n | Nil : ('b, 'b) heter_list\n\n(* Existential Black Boxes. *)\n(* Used to abstract some existential type parameters. *)\n\n(* GADT type associating a padding and an fmtty. *)\n(* See the type_padding function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) padding_fmtty_ebb = Padding_fmtty_EBB :\n ('x, 'y) padding * ('y, 'b, 'c, 'd, 'e, 'f) fmtty ->\n ('x, 'b, 'c, 'd, 'e, 'f) padding_fmtty_ebb\n\n(* GADT type associating a padding, a precision and an fmtty. *)\n(* See the type_padprec function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) padprec_fmtty_ebb = Padprec_fmtty_EBB :\n ('x, 'y) padding * ('y, 'z) precision * ('z, 'b, 'c, 'd, 'e, 'f) fmtty ->\n ('x, 'b, 'c, 'd, 'e, 'f) padprec_fmtty_ebb\n\n(* GADT type associating a padding and an fmt. *)\n(* See make_padding_fmt_ebb and parse_format functions. *)\ntype ('a, 'b, 'c, 'e, 'f) padding_fmt_ebb = Padding_fmt_EBB :\n (_, 'x -> 'a) padding *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'e, 'f) padding_fmt_ebb\n\n(* GADT type associating a precision and an fmt. *)\n(* See make_precision_fmt_ebb and parse_format functions. *)\ntype ('a, 'b, 'c, 'e, 'f) precision_fmt_ebb = Precision_fmt_EBB :\n (_, 'x -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('x, 'b, 'c, 'e, 'f) precision_fmt_ebb\n\n(* GADT type associating a padding, a precision and an fmt. *)\n(* See make_padprec_fmt_ebb and parse_format functions. *)\ntype ('p, 'b, 'c, 'e, 'f) padprec_fmt_ebb = Padprec_fmt_EBB :\n ('x, 'y) padding * ('y, 'p -> 'a) precision *\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('p, 'b, 'c, 'e, 'f) padprec_fmt_ebb\n\n(* Abstract the 'a and 'd parameters of an fmt. *)\n(* Output type of the format parsing function. *)\ntype ('b, 'c, 'e, 'f) fmt_ebb = Fmt_EBB :\n ('a, 'b, 'c, 'd, 'e, 'f) fmt ->\n ('b, 'c, 'e, 'f) fmt_ebb\n\n(* GADT type associating an fmtty and an fmt. *)\n(* See the type_format_gen function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) fmt_fmtty_ebb = Fmt_fmtty_EBB :\n ('a, 'b, 'c, 'd, 'y, 'x) fmt *\n ('x, 'b, 'c, 'y, 'e, 'f) fmtty ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmt_fmtty_ebb\n\n(* GADT type associating an fmtty and an fmt. *)\n(* See the type_ignored_format_substitution function. *)\ntype ('a, 'b, 'c, 'd, 'e, 'f) fmtty_fmt_ebb = Fmtty_fmt_EBB :\n ('a, 'b, 'c, 'd, 'y, 'x) fmtty *\n ('x, 'b, 'c, 'y, 'e, 'f) fmt_fmtty_ebb ->\n ('a, 'b, 'c, 'd, 'e, 'f) fmtty_fmt_ebb\n\n(* Abstract all fmtty type parameters. *)\n(* Used to compare format types. *)\ntype fmtty_ebb = Fmtty_EBB : ('a, 'b, 'c, 'd, 'e, 'f) fmtty -> fmtty_ebb\n\n(* Abstract all padding type parameters. *)\n(* Used to compare paddings. *)\ntype padding_ebb = Padding_EBB : ('a, 'b) padding -> padding_ebb\n\n(* Abstract all precision type parameters. *)\n(* Used to compare precisions. *)\ntype precision_ebb = Precision_EBB : ('a, 'b) precision -> precision_ebb\n\n(******************************************************************************)\n (* Constants *)\n\n(* Default precision for float printing. *)\nlet default_float_precision = 6\n\n(******************************************************************************)\n (* Externals *)\n\nexternal format_float: string -> float -> string\n = \"caml_format_float\"\nexternal format_int: string -> int -> string\n = \"caml_format_int\"\nexternal format_int32: string -> int32 -> string\n = \"caml_int32_format\"\nexternal format_nativeint: string -> nativeint -> string\n = \"caml_nativeint_format\"\nexternal format_int64: string -> int64 -> string\n = \"caml_int64_format\"\n\n(******************************************************************************)\n (* Tools to pretty-print formats *)\n\n(* Type of extensible character buffers. *)\ntype buffer = {\n mutable ind : int;\n mutable bytes : bytes;\n}\n\n(* Create a fresh buffer. *)\nlet buffer_create init_size = { ind = 0; bytes = Bytes.create init_size }\n\n(* Check size of the buffer and grow it if needed. *)\nlet buffer_check_size buf overhead =\n let len = Bytes.length buf.bytes in\n let min_len = buf.ind + overhead in\n if min_len > len then (\n let new_len = max (len * 2) min_len in\n let new_str = Bytes.create new_len in\n Bytes.blit buf.bytes 0 new_str 0 len;\n buf.bytes <- new_str;\n )\n\n(* Add the character `c' to the buffer `buf'. *)\nlet buffer_add_char buf c =\n buffer_check_size buf 1;\n Bytes.set buf.bytes buf.ind c;\n buf.ind <- buf.ind + 1\n\n(* Add the string `s' to the buffer `buf'. *)\nlet buffer_add_string buf s =\n let str_len = String.length s in\n buffer_check_size buf str_len;\n String.blit s 0 buf.bytes buf.ind str_len;\n buf.ind <- buf.ind + str_len\n\n(* Get the content of the buffer. *)\nlet buffer_contents buf =\n Bytes.sub_string buf.bytes 0 buf.ind\n\n(***)\n\n(* Convert an integer conversion to char. *)\nlet char_of_iconv iconv = match iconv with\n | Int_d | Int_pd | Int_sd -> 'd' | Int_i | Int_pi | Int_si -> 'i'\n | Int_x | Int_Cx -> 'x' | Int_X | Int_CX -> 'X' | Int_o | Int_Co -> 'o'\n | Int_u -> 'u'\n\n(* Convert a float conversion to char. *)\nlet char_of_fconv fconv = match fconv with\n | Float_f | Float_pf | Float_sf -> 'f' | Float_e | Float_pe | Float_se -> 'e'\n | Float_E | Float_pE | Float_sE -> 'E' | Float_g | Float_pg | Float_sg -> 'g'\n | Float_G | Float_pG | Float_sG -> 'G' | Float_F -> 'F'\n\n(* Convert a scanning counter to char. *)\nlet char_of_counter counter = match counter with\n | Line_counter -> 'l'\n | Char_counter -> 'n'\n | Token_counter -> 'N'\n\n(***)\n\n(* Print a char_set in a buffer with the OCaml format lexical convention. *)\nlet bprint_char_set buf char_set =\n let rec print_start set =\n let is_alone c =\n let before, after = Char.(chr (code c - 1), chr (code c + 1)) in\n is_in_char_set set c\n && not (is_in_char_set set before && is_in_char_set set after) in\n if is_alone ']' then buffer_add_char buf ']';\n print_out set 1;\n if is_alone '-' then buffer_add_char buf '-';\n and print_out set i =\n if i < 256 then\n if is_in_char_set set (char_of_int i) then print_first set i\n else print_out set (i + 1)\n and print_first set i =\n match char_of_int i with\n | '\\255' -> print_char buf 255;\n | ']' | '-' -> print_out set (i + 1);\n | _ -> print_second set (i + 1);\n and print_second set i =\n if is_in_char_set set (char_of_int i) then\n match char_of_int i with\n | '\\255' ->\n print_char buf 254;\n print_char buf 255;\n | ']' | '-' when not (is_in_char_set set (char_of_int (i + 1))) ->\n print_char buf (i - 1);\n print_out set (i + 1);\n | _ when not (is_in_char_set set (char_of_int (i + 1))) ->\n print_char buf (i - 1);\n print_char buf i;\n print_out set (i + 2);\n | _ ->\n print_in set (i - 1) (i + 2);\n else (\n print_char buf (i - 1);\n print_out set (i + 1);\n )\n and print_in set i j =\n if j = 256 || not (is_in_char_set set (char_of_int j)) then (\n print_char buf i;\n print_char buf (int_of_char '-');\n print_char buf (j - 1);\n if j < 256 then print_out set (j + 1);\n ) else\n print_in set i (j + 1);\n and print_char buf i = match char_of_int i with\n | '%' -> buffer_add_char buf '%'; buffer_add_char buf '%';\n | '@' -> buffer_add_char buf '%'; buffer_add_char buf '@';\n | c -> buffer_add_char buf c;\n in\n buffer_add_char buf '[';\n print_start (\n if is_in_char_set char_set '\\000'\n then ( buffer_add_char buf '^'; rev_char_set char_set )\n else char_set\n );\n buffer_add_char buf ']'\n\n(***)\n\n(* Print a padty in a buffer with the format-like syntax. *)\nlet bprint_padty buf padty = match padty with\n | Left -> buffer_add_char buf '-'\n | Right -> ()\n | Zeros -> buffer_add_char buf '0'\n\n(* Print the '_' of an ignored flag if needed. *)\nlet bprint_ignored_flag buf ign_flag =\n if ign_flag then buffer_add_char buf '_'\n\n(***)\n\nlet bprint_pad_opt buf pad_opt = match pad_opt with\n | None -> ()\n | Some width -> buffer_add_string buf (string_of_int width)\n\n(***)\n\n(* Print padding in a buffer with the format-like syntax. *)\nlet bprint_padding : type a b . buffer -> (a, b) padding -> unit =\nfun buf pad -> match pad with\n | No_padding -> ()\n | Lit_padding (padty, n) ->\n bprint_padty buf padty;\n buffer_add_string buf (string_of_int n);\n | Arg_padding padty ->\n bprint_padty buf padty;\n buffer_add_char buf '*'\n\n(* Print precision in a buffer with the format-like syntax. *)\nlet bprint_precision : type a b . buffer -> (a, b) precision -> unit =\n fun buf prec -> match prec with\n | No_precision -> ()\n | Lit_precision n ->\n buffer_add_char buf '.';\n buffer_add_string buf (string_of_int n);\n | Arg_precision ->\n buffer_add_string buf \".*\"\n\n(***)\n\n(* Print the optionnal '+', ' ' or '#' associated to an int conversion. *)\nlet bprint_iconv_flag buf iconv = match iconv with\n | Int_pd | Int_pi -> buffer_add_char buf '+'\n | Int_sd | Int_si -> buffer_add_char buf ' '\n | Int_Cx | Int_CX | Int_Co -> buffer_add_char buf '#'\n | Int_d | Int_i | Int_x | Int_X | Int_o | Int_u -> ()\n\n(* Print an complete int format in a buffer (ex: \"%3.*d\"). *)\nlet bprint_int_fmt buf ign_flag iconv pad prec =\n buffer_add_char buf '%';\n bprint_ignored_flag buf ign_flag;\n bprint_iconv_flag buf iconv;\n bprint_padding buf pad;\n bprint_precision buf prec;\n buffer_add_char buf (char_of_iconv iconv)\n\n(* Print a complete int32, nativeint or int64 format in a buffer. *)\nlet bprint_altint_fmt buf ign_flag iconv pad prec c =\n buffer_add_char buf '%';\n bprint_ignored_flag buf ign_flag;\n bprint_iconv_flag buf iconv;\n bprint_padding buf pad;\n bprint_precision buf prec;\n buffer_add_char buf c;\n buffer_add_char buf (char_of_iconv iconv)\n\n(***)\n\n(* Print the optionnal '+' associated to a float conversion. *)\nlet bprint_fconv_flag buf fconv = match fconv with\n | Float_pf | Float_pe | Float_pE | Float_pg | Float_pG ->\n buffer_add_char buf '+'\n | Float_sf | Float_se | Float_sE | Float_sg | Float_sG ->\n buffer_add_char buf ' '\n | Float_f | Float_e | Float_E | Float_g | Float_G | Float_F ->\n ()\n\n(* Print a complete float format in a buffer (ex: \"%+*.3f\"). *)\nlet bprint_float_fmt buf ign_flag fconv pad prec =\n buffer_add_char buf '%';\n bprint_ignored_flag buf ign_flag;\n bprint_fconv_flag buf fconv;\n bprint_padding buf pad;\n bprint_precision buf prec;\n buffer_add_char buf (char_of_fconv fconv)\n\n(* Compute the literal string representation of a formatting_lit. *)\n(* Also used by Printf and Scanf where formatting is not interpreted. *)\nlet string_of_formatting_lit formatting_lit = match formatting_lit with\n | Close_box -> \"@]\"\n | Close_tag -> \"@}\"\n | Break (str, _, _) -> str\n | FFlush -> \"@?\"\n | Force_newline -> \"@\\n\"\n | Flush_newline -> \"@.\"\n | Magic_size (str, _) -> str\n | Escaped_at -> \"@@\"\n | Escaped_percent -> \"@%\"\n | Scan_indic c -> \"@\" ^ (String.make 1 c)\n\n(* Compute the literal string representation of a formatting. *)\n(* Also used by Printf and Scanf where formatting is not interpreted. *)\nlet string_of_formatting_gen : type a b c d e f .\n (a, b, c, d, e, f) formatting_gen -> string =\n fun formatting_gen -> match formatting_gen with\n | Open_tag (Format (_, str)) -> str\n | Open_box (Format (_, str)) -> str\n\n(***)\n\n(* Print a literal char in a buffer, escape '%' by \"%%\". *)\nlet bprint_char_literal buf chr = match chr with\n | '%' -> buffer_add_string buf \"%%\"\n | _ -> buffer_add_char buf chr\n\n(* Print a literal string in a buffer, escape all '%' by \"%%\". *)\nlet bprint_string_literal buf str =\n for i = 0 to String.length str - 1 do\n bprint_char_literal buf str.[i]\n done\n\n(******************************************************************************)\n (* Format pretty-printing *)\n\n(* Print a complete format type (an fmtty) in a buffer. *)\nlet rec bprint_fmtty : type a b c d e f g h i j k l .\n buffer -> (a, b, c, d, e, f, g, h, i, j, k, l) fmtty_rel -> unit =\nfun buf fmtty -> match fmtty with\n | Char_ty rest -> buffer_add_string buf \"%c\"; bprint_fmtty buf rest;\n | String_ty rest -> buffer_add_string buf \"%s\"; bprint_fmtty buf rest;\n | Int_ty rest -> buffer_add_string buf \"%i\"; bprint_fmtty buf rest;\n | Int32_ty rest -> buffer_add_string buf \"%li\"; bprint_fmtty buf rest;\n | Nativeint_ty rest -> buffer_add_string buf \"%ni\"; bprint_fmtty buf rest;\n | Int64_ty rest -> buffer_add_string buf \"%Li\"; bprint_fmtty buf rest;\n | Float_ty rest -> buffer_add_string buf \"%f\"; bprint_fmtty buf rest;\n | Bool_ty rest -> buffer_add_string buf \"%B\"; bprint_fmtty buf rest;\n | Alpha_ty rest -> buffer_add_string buf \"%a\"; bprint_fmtty buf rest;\n | Theta_ty rest -> buffer_add_string buf \"%t\"; bprint_fmtty buf rest;\n | Any_ty rest -> buffer_add_string buf \"%?\"; bprint_fmtty buf rest;\n | Reader_ty rest -> buffer_add_string buf \"%r\"; bprint_fmtty buf rest;\n\n | Ignored_reader_ty rest ->\n buffer_add_string buf \"%_r\";\n bprint_fmtty buf rest;\n\n | Format_arg_ty (sub_fmtty, rest) ->\n buffer_add_string buf \"%{\"; bprint_fmtty buf sub_fmtty;\n buffer_add_string buf \"%}\"; bprint_fmtty buf rest;\n | Format_subst_ty (sub_fmtty, _, rest) ->\n buffer_add_string buf \"%(\"; bprint_fmtty buf sub_fmtty;\n buffer_add_string buf \"%)\"; bprint_fmtty buf rest;\n\n | End_of_fmtty -> ()\n\n(***)\n\nlet rec int_of_custom_arity : type a b c .\n (a, b, c) custom_arity -> int =\n function\n | Custom_zero -> 0\n | Custom_succ x -> 1 + int_of_custom_arity x\n\n(* Print a complete format in a buffer. *)\nlet bprint_fmt buf fmt =\n let rec fmtiter : type a b c d e f .\n (a, b, c, d, e, f) fmt -> bool -> unit =\n fun fmt ign_flag -> match fmt with\n | String (pad, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_padding buf pad; buffer_add_char buf 's';\n fmtiter rest false;\n | Caml_string (pad, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_padding buf pad; buffer_add_char buf 'S';\n fmtiter rest false;\n\n | Int (iconv, pad, prec, rest) ->\n bprint_int_fmt buf ign_flag iconv pad prec;\n fmtiter rest false;\n | Int32 (iconv, pad, prec, rest) ->\n bprint_altint_fmt buf ign_flag iconv pad prec 'l';\n fmtiter rest false;\n | Nativeint (iconv, pad, prec, rest) ->\n bprint_altint_fmt buf ign_flag iconv pad prec 'n';\n fmtiter rest false;\n | Int64 (iconv, pad, prec, rest) ->\n bprint_altint_fmt buf ign_flag iconv pad prec 'L';\n fmtiter rest false;\n | Float (fconv, pad, prec, rest) ->\n bprint_float_fmt buf ign_flag fconv pad prec;\n fmtiter rest false;\n\n | Char rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'c'; fmtiter rest false;\n | Caml_char rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'C'; fmtiter rest false;\n | Bool rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'B'; fmtiter rest false;\n | Alpha rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'a'; fmtiter rest false;\n | Theta rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 't'; fmtiter rest false;\n | Custom (arity, _, rest) ->\n for _i = 1 to int_of_custom_arity arity do\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf '?';\n done;\n fmtiter rest false;\n | Reader rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf 'r'; fmtiter rest false;\n | Flush rest ->\n buffer_add_string buf \"%!\";\n fmtiter rest ign_flag;\n\n | String_literal (str, rest) ->\n bprint_string_literal buf str;\n fmtiter rest ign_flag;\n | Char_literal (chr, rest) ->\n bprint_char_literal buf chr;\n fmtiter rest ign_flag;\n\n | Format_arg (pad_opt, fmtty, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_pad_opt buf pad_opt; buffer_add_char buf '{';\n bprint_fmtty buf fmtty; buffer_add_char buf '%'; buffer_add_char buf '}';\n fmtiter rest false;\n | Format_subst (pad_opt, fmtty, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_pad_opt buf pad_opt; buffer_add_char buf '(';\n bprint_fmtty buf fmtty; buffer_add_char buf '%'; buffer_add_char buf ')';\n fmtiter rest false;\n\n | Scan_char_set (width_opt, char_set, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_pad_opt buf width_opt; bprint_char_set buf char_set;\n fmtiter rest false;\n | Scan_get_counter (counter, rest) ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n buffer_add_char buf (char_of_counter counter);\n fmtiter rest false;\n | Scan_next_char rest ->\n buffer_add_char buf '%'; bprint_ignored_flag buf ign_flag;\n bprint_string_literal buf \"0c\"; fmtiter rest false;\n\n | Ignored_param (ign, rest) ->\n let Param_format_EBB fmt' = param_format_of_ignored_format ign rest in\n fmtiter fmt' true;\n\n | Formatting_lit (fmting_lit, rest) ->\n bprint_string_literal buf (string_of_formatting_lit fmting_lit);\n fmtiter rest ign_flag;\n | Formatting_gen (fmting_gen, rest) ->\n bprint_string_literal buf \"@{\";\n bprint_string_literal buf (string_of_formatting_gen fmting_gen);\n fmtiter rest ign_flag;\n\n | End_of_format -> ()\n\n in fmtiter fmt false\n\n(***)\n\n(* Convert a format to string. *)\nlet string_of_fmt fmt =\n let buf = buffer_create 16 in\n bprint_fmt buf fmt;\n buffer_contents buf\n\n(******************************************************************************)\n (* Type extraction *)\n\ntype (_, _) eq = Refl : ('a, 'a) eq\n\n(* Invariant: this function is the identity on values.\n\n In particular, if (ty1, ty2) have equal values, then\n (trans (symm ty1) ty2) respects the 'trans' precondition. *)\nlet rec symm : type a1 b1 c1 d1 e1 f1 a2 b2 c2 d2 e2 f2 .\n (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel\n-> (a2, b2, c2, d2, e2, f2,\n a1, b1, c1, d1, e1, f1) fmtty_rel\n= function\n | Char_ty rest -> Char_ty (symm rest)\n | Int_ty rest -> Int_ty (symm rest)\n | Int32_ty rest -> Int32_ty (symm rest)\n | Int64_ty rest -> Int64_ty (symm rest)\n | Nativeint_ty rest -> Nativeint_ty (symm rest)\n | Float_ty rest -> Float_ty (symm rest)\n | Bool_ty rest -> Bool_ty (symm rest)\n | String_ty rest -> String_ty (symm rest)\n | Theta_ty rest -> Theta_ty (symm rest)\n | Alpha_ty rest -> Alpha_ty (symm rest)\n | Any_ty rest -> Any_ty (symm rest)\n | Reader_ty rest -> Reader_ty (symm rest)\n | Ignored_reader_ty rest -> Ignored_reader_ty (symm rest)\n | Format_arg_ty (ty, rest) ->\n Format_arg_ty (ty, symm rest)\n | Format_subst_ty (ty1, ty2, rest) ->\n Format_subst_ty (ty2, ty1, symm rest)\n | End_of_fmtty -> End_of_fmtty\n\nlet rec fmtty_rel_det : type a1 b c d1 e1 f1 a2 d2 e2 f2 .\n (a1, b, c, d1, e1, f1,\n a2, b, c, d2, e2, f2) fmtty_rel ->\n ((f1, f2) eq -> (a1, a2) eq)\n * ((a1, a2) eq -> (f1, f2) eq)\n * ((e1, e2) eq -> (d1, d2) eq)\n * ((d1, d2) eq -> (e1, e2) eq)\n= function\n | End_of_fmtty ->\n (fun Refl -> Refl),\n (fun Refl -> Refl),\n (fun Refl -> Refl),\n (fun Refl -> Refl)\n | Char_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | String_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Int_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Int32_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Int64_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Nativeint_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Float_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Bool_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n\n | Theta_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Alpha_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Any_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Reader_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n (fun Refl -> let Refl = ed Refl in Refl),\n (fun Refl -> let Refl = de Refl in Refl)\n | Ignored_reader_ty rest ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n (fun Refl -> let Refl = ed Refl in Refl),\n (fun Refl -> let Refl = de Refl in Refl)\n | Format_arg_ty (_ty, rest) ->\n let fa, af, ed, de = fmtty_rel_det rest in\n (fun Refl -> let Refl = fa Refl in Refl),\n (fun Refl -> let Refl = af Refl in Refl),\n ed, de\n | Format_subst_ty (ty1, ty2, rest) ->\n let fa, af, ed, de = fmtty_rel_det rest in\n let ty = trans (symm ty1) ty2 in\n let ag, ga, dj, jd = fmtty_rel_det ty in\n (fun Refl -> let Refl = fa Refl in let Refl = ag Refl in Refl),\n (fun Refl -> let Refl = ga Refl in let Refl = af Refl in Refl),\n (fun Refl -> let Refl = ed Refl in let Refl = dj Refl in Refl),\n (fun Refl -> let Refl = jd Refl in let Refl = de Refl in Refl)\n\n(* Precondition: we assume that the two fmtty_rel arguments have equal\n values (at possibly distinct types); this invariant comes from the way\n fmtty_rel witnesses are produced by the type-checker\n\n The code below uses (assert false) when this assumption is broken. The\n code pattern is the following:\n\n | Foo x, Foo y ->\n (* case where indeed both values\n start with constructor Foo *)\n | Foo _, _\n | _, Foo _ ->\n (* different head constructors: broken precondition *)\n assert false\n*)\nand trans : type\n a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2\n a3 b3 c3 d3 e3 f3\n.\n (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel\n-> (a2, b2, c2, d2, e2, f2,\n a3, b3, c3, d3, e3, f3) fmtty_rel\n-> (a1, b1, c1, d1, e1, f1,\n a3, b3, c3, d3, e3, f3) fmtty_rel\n= fun ty1 ty2 -> match ty1, ty2 with\n | Char_ty rest1, Char_ty rest2 -> Char_ty (trans rest1 rest2)\n | String_ty rest1, String_ty rest2 -> String_ty (trans rest1 rest2)\n | Bool_ty rest1, Bool_ty rest2 -> Bool_ty (trans rest1 rest2)\n | Int_ty rest1, Int_ty rest2 -> Int_ty (trans rest1 rest2)\n | Int32_ty rest1, Int32_ty rest2 -> Int32_ty (trans rest1 rest2)\n | Int64_ty rest1, Int64_ty rest2 -> Int64_ty (trans rest1 rest2)\n | Nativeint_ty rest1, Nativeint_ty rest2 -> Nativeint_ty (trans rest1 rest2)\n | Float_ty rest1, Float_ty rest2 -> Float_ty (trans rest1 rest2)\n\n | Alpha_ty rest1, Alpha_ty rest2 -> Alpha_ty (trans rest1 rest2)\n | Alpha_ty _, _ -> assert false\n | _, Alpha_ty _ -> assert false\n\n | Theta_ty rest1, Theta_ty rest2 -> Theta_ty (trans rest1 rest2)\n | Theta_ty _, _ -> assert false\n | _, Theta_ty _ -> assert false\n\n | Any_ty rest1, Any_ty rest2 -> Any_ty (trans rest1 rest2)\n | Any_ty _, _ -> assert false\n | _, Any_ty _ -> assert false\n\n | Reader_ty rest1, Reader_ty rest2 -> Reader_ty (trans rest1 rest2)\n | Reader_ty _, _ -> assert false\n | _, Reader_ty _ -> assert false\n\n | Ignored_reader_ty rest1, Ignored_reader_ty rest2 ->\n Ignored_reader_ty (trans rest1 rest2)\n | Ignored_reader_ty _, _ -> assert false\n | _, Ignored_reader_ty _ -> assert false\n\n | Format_arg_ty (ty1, rest1), Format_arg_ty (ty2, rest2) ->\n Format_arg_ty (trans ty1 ty2, trans rest1 rest2)\n | Format_arg_ty _, _ -> assert false\n | _, Format_arg_ty _ -> assert false\n\n | Format_subst_ty (ty11, ty12, rest1),\n Format_subst_ty (ty21, ty22, rest2) ->\n let ty = trans (symm ty12) ty21 in\n let _, f2, _, f4 = fmtty_rel_det ty in\n let Refl = f2 Refl in\n let Refl = f4 Refl in\n Format_subst_ty (ty11, ty22, trans rest1 rest2)\n | Format_subst_ty _, _ -> assert false\n | _, Format_subst_ty _ -> assert false\n\n | End_of_fmtty, End_of_fmtty -> End_of_fmtty\n | End_of_fmtty, _ -> assert false\n | _, End_of_fmtty -> assert false\n\nlet rec fmtty_of_formatting_gen : type a b c d e f .\n (a, b, c, d, e, f) formatting_gen ->\n (a, b, c, d, e, f) fmtty =\nfun formatting_gen -> match formatting_gen with\n | Open_tag (Format (fmt, _)) -> fmtty_of_fmt fmt\n | Open_box (Format (fmt, _)) -> fmtty_of_fmt fmt\n\n(* Extract the type representation (an fmtty) of a format. *)\nand fmtty_of_fmt : type a b c d e f .\n (a, b, c, d, e, f) fmt -> (a, b, c, d, e, f) fmtty =\nfun fmtty -> match fmtty with\n | String (pad, rest) ->\n fmtty_of_padding_fmtty pad (String_ty (fmtty_of_fmt rest))\n | Caml_string (pad, rest) ->\n fmtty_of_padding_fmtty pad (String_ty (fmtty_of_fmt rest))\n\n | Int (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Int_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Int32 (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Int32_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Nativeint (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Nativeint_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Int64 (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Int64_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n | Float (_, pad, prec, rest) ->\n let ty_rest = fmtty_of_fmt rest in\n let prec_ty = fmtty_of_precision_fmtty prec (Float_ty ty_rest) in\n fmtty_of_padding_fmtty pad prec_ty\n\n | Char rest -> Char_ty (fmtty_of_fmt rest)\n | Caml_char rest -> Char_ty (fmtty_of_fmt rest)\n | Bool rest -> Bool_ty (fmtty_of_fmt rest)\n | Alpha rest -> Alpha_ty (fmtty_of_fmt rest)\n | Theta rest -> Theta_ty (fmtty_of_fmt rest)\n | Custom (arity, _, rest) -> fmtty_of_custom arity (fmtty_of_fmt rest)\n | Reader rest -> Reader_ty (fmtty_of_fmt rest)\n\n | Format_arg (_, ty, rest) ->\n Format_arg_ty (ty, fmtty_of_fmt rest)\n | Format_subst (_, ty, rest) ->\n Format_subst_ty (ty, ty, fmtty_of_fmt rest)\n\n | Flush rest -> fmtty_of_fmt rest\n | String_literal (_, rest) -> fmtty_of_fmt rest\n | Char_literal (_, rest) -> fmtty_of_fmt rest\n\n | Scan_char_set (_, _, rest) -> String_ty (fmtty_of_fmt rest)\n | Scan_get_counter (_, rest) -> Int_ty (fmtty_of_fmt rest)\n | Scan_next_char rest -> Char_ty (fmtty_of_fmt rest)\n | Ignored_param (ign, rest) -> fmtty_of_ignored_format ign rest\n | Formatting_lit (_, rest) -> fmtty_of_fmt rest\n | Formatting_gen (fmting_gen, rest) ->\n concat_fmtty (fmtty_of_formatting_gen fmting_gen) (fmtty_of_fmt rest)\n\n | End_of_format -> End_of_fmtty\n\nand fmtty_of_custom : type x y a b c d e f .\n (a, x, y) custom_arity -> (a, b, c, d, e, f) fmtty ->\n (y, b, c, d, e, f) fmtty =\nfun arity fmtty -> match arity with\n | Custom_zero -> fmtty\n | Custom_succ arity -> Any_ty (fmtty_of_custom arity fmtty)\n\n(* Extract the fmtty of an ignored parameter followed by the rest of\n the format. *)\nand fmtty_of_ignored_format : type x y a b c d e f .\n (a, b, c, d, y, x) ignored ->\n (x, b, c, y, e, f) fmt ->\n (a, b, c, d, e, f) fmtty =\nfun ign fmt -> match ign with\n | Ignored_char -> fmtty_of_fmt fmt\n | Ignored_caml_char -> fmtty_of_fmt fmt\n | Ignored_string _ -> fmtty_of_fmt fmt\n | Ignored_caml_string _ -> fmtty_of_fmt fmt\n | Ignored_int (_, _) -> fmtty_of_fmt fmt\n | Ignored_int32 (_, _) -> fmtty_of_fmt fmt\n | Ignored_nativeint (_, _) -> fmtty_of_fmt fmt\n | Ignored_int64 (_, _) -> fmtty_of_fmt fmt\n | Ignored_float (_, _) -> fmtty_of_fmt fmt\n | Ignored_bool -> fmtty_of_fmt fmt\n | Ignored_format_arg _ -> fmtty_of_fmt fmt\n | Ignored_format_subst (_, fmtty) -> concat_fmtty fmtty (fmtty_of_fmt fmt)\n | Ignored_reader -> Ignored_reader_ty (fmtty_of_fmt fmt)\n | Ignored_scan_char_set _ -> fmtty_of_fmt fmt\n | Ignored_scan_get_counter _ -> fmtty_of_fmt fmt\n | Ignored_scan_next_char -> fmtty_of_fmt fmt\n\n(* Add an Int_ty node if padding is taken as an extra argument (ex: \"%*s\"). *)\nand fmtty_of_padding_fmtty : type x a b c d e f .\n (x, a) padding -> (a, b, c, d, e, f) fmtty -> (x, b, c, d, e, f) fmtty =\n fun pad fmtty -> match pad with\n | No_padding -> fmtty\n | Lit_padding _ -> fmtty\n | Arg_padding _ -> Int_ty fmtty\n\n(* Add an Int_ty node if precision is taken as an extra argument (ex: \"%.*f\").*)\nand fmtty_of_precision_fmtty : type x a b c d e f .\n (x, a) precision -> (a, b, c, d, e, f) fmtty -> (x, b, c, d, e, f) fmtty =\n fun prec fmtty -> match prec with\n | No_precision -> fmtty\n | Lit_precision _ -> fmtty\n | Arg_precision -> Int_ty fmtty\n\n(******************************************************************************)\n (* Format typing *)\n\n(* Exception raised when a format does not match a given format type. *)\nexception Type_mismatch\n\n(* Type a padding. *)\n(* Take an Int_ty from the fmtty if the integer should be kept as argument. *)\n(* Raise Type_mismatch in case of type mismatch. *)\nlet type_padding : type a b c d e f x y .\n (x, y) padding -> (a, b, c, d, e, f) fmtty ->\n (a, b, c, d, e, f) padding_fmtty_ebb =\nfun pad fmtty -> match pad, fmtty with\n | No_padding, _ -> Padding_fmtty_EBB (No_padding, fmtty)\n | Lit_padding (padty, w), _ -> Padding_fmtty_EBB (Lit_padding (padty,w),fmtty)\n | Arg_padding padty, Int_ty rest -> Padding_fmtty_EBB (Arg_padding padty,rest)\n | _ -> raise Type_mismatch\n\n(* Convert a (upadding, uprecision) to a (padding, precision). *)\n(* Take one or two Int_ty from the fmtty if needed. *)\n(* Raise Type_mismatch in case of type mismatch. *)\nlet type_padprec : type a b c d e f x y z .\n (x, y) padding -> (y, z) precision -> (a, b, c, d, e, f) fmtty ->\n (a, b, c, d, e, f) padprec_fmtty_ebb =\nfun pad prec fmtty -> match prec, type_padding pad fmtty with\n | No_precision, Padding_fmtty_EBB (pad, rest) ->\n Padprec_fmtty_EBB (pad, No_precision, rest)\n | Lit_precision p, Padding_fmtty_EBB (pad, rest) ->\n Padprec_fmtty_EBB (pad, Lit_precision p, rest)\n | Arg_precision, Padding_fmtty_EBB (pad, Int_ty rest) ->\n Padprec_fmtty_EBB (pad, Arg_precision, rest)\n | _, Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n\n(* Type a format according to an fmtty. *)\n(* If typing succeed, generate a copy of the format with the same\n type parameters as the fmtty. *)\n(* Raise a Failure with an error message in case of type mismatch. *)\nlet rec type_format :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2 .\n (a1, b1, c1, d1, e1, f1) fmt\n -> (a2, b2, c2, d2, e2, f2) fmtty\n -> (a2, b2, c2, d2, e2, f2) fmt\n= fun fmt fmtty -> match type_format_gen fmt fmtty with\n | Fmt_fmtty_EBB (fmt', End_of_fmtty) -> fmt'\n | _ -> raise Type_mismatch\n\nand type_format_gen :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2 .\n (a1, b1, c1, d1, e1, f1) fmt\n -> (a2, b2, c2, d2, e2, f2) fmtty\n -> (a2, b2, c2, d2, e2, f2) fmt_fmtty_ebb\n= fun fmt fmtty -> match fmt, fmtty with\n | Char fmt_rest, Char_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Char fmt', fmtty')\n | Caml_char fmt_rest, Char_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Caml_char fmt', fmtty')\n | String (pad, fmt_rest), _ -> (\n match type_padding pad fmtty with\n | Padding_fmtty_EBB (pad, String_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (String (pad, fmt'), fmtty')\n | Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n )\n | Caml_string (pad, fmt_rest), _ -> (\n match type_padding pad fmtty with\n | Padding_fmtty_EBB (pad, String_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Caml_string (pad, fmt'), fmtty')\n | Padding_fmtty_EBB (_, _) -> raise Type_mismatch\n )\n | Int (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Int_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Int (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Int32 (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Int32_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Int32 (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Nativeint (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Nativeint_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Nativeint (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Int64 (iconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Int64_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Int64 (iconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Float (fconv, pad, prec, fmt_rest), _ -> (\n match type_padprec pad prec fmtty with\n | Padprec_fmtty_EBB (pad, prec, Float_ty fmtty_rest) ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Float (fconv, pad, prec, fmt'), fmtty')\n | Padprec_fmtty_EBB (_, _, _) -> raise Type_mismatch\n )\n | Bool fmt_rest, Bool_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Bool fmt', fmtty')\n | Flush fmt_rest, fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Flush fmt', fmtty')\n\n | String_literal (str, fmt_rest), fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (String_literal (str, fmt'), fmtty')\n | Char_literal (chr, fmt_rest), fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Char_literal (chr, fmt'), fmtty')\n\n | Format_arg (pad_opt, sub_fmtty, fmt_rest),\n Format_arg_ty (sub_fmtty', fmtty_rest) ->\n if Fmtty_EBB sub_fmtty <> Fmtty_EBB sub_fmtty' then raise Type_mismatch;\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Format_arg (pad_opt, sub_fmtty', fmt'), fmtty')\n | Format_subst (pad_opt, sub_fmtty, fmt_rest),\n Format_subst_ty (sub_fmtty1, _sub_fmtty2, fmtty_rest) ->\n if Fmtty_EBB (erase_rel sub_fmtty) <> Fmtty_EBB (erase_rel sub_fmtty1) then\n raise Type_mismatch;\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest (erase_rel fmtty_rest) in\n Fmt_fmtty_EBB (Format_subst (pad_opt, sub_fmtty1, fmt'), fmtty')\n (* Printf and Format specific constructors: *)\n | Alpha fmt_rest, Alpha_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Alpha fmt', fmtty')\n | Theta fmt_rest, Theta_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Theta fmt', fmtty')\n\n (* Format specific constructors: *)\n | Formatting_lit (formatting_lit, fmt_rest), fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Formatting_lit (formatting_lit, fmt'), fmtty')\n | Formatting_gen (formatting_gen, fmt_rest), fmtty_rest ->\n type_formatting_gen formatting_gen fmt_rest fmtty_rest\n\n (* Scanf specific constructors: *)\n | Reader fmt_rest, Reader_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Reader fmt', fmtty')\n | Scan_char_set (width_opt, char_set, fmt_rest), String_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Scan_char_set (width_opt, char_set, fmt'), fmtty')\n | Scan_get_counter (counter, fmt_rest), Int_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt_rest fmtty_rest in\n Fmt_fmtty_EBB (Scan_get_counter (counter, fmt'), fmtty')\n | Ignored_param (ign, rest), fmtty_rest ->\n type_ignored_param ign rest fmtty_rest\n\n | End_of_format, fmtty_rest -> Fmt_fmtty_EBB (End_of_format, fmtty_rest)\n\n | _ -> raise Type_mismatch\n\nand type_formatting_gen : type a1 a3 b1 b3 c1 c3 d1 d3 e1 e2 e3 f1 f2 f3 .\n (a1, b1, c1, d1, e1, f1) formatting_gen ->\n (f1, b1, c1, e1, e2, f2) fmt ->\n (a3, b3, c3, d3, e3, f3) fmtty ->\n (a3, b3, c3, d3, e3, f3) fmt_fmtty_ebb =\nfun formatting_gen fmt0 fmtty0 -> match formatting_gen with\n | Open_tag (Format (fmt1, str)) ->\n let Fmt_fmtty_EBB (fmt2, fmtty2) = type_format_gen fmt1 fmtty0 in\n let Fmt_fmtty_EBB (fmt3, fmtty3) = type_format_gen fmt0 fmtty2 in\n Fmt_fmtty_EBB (Formatting_gen (Open_tag (Format (fmt2, str)), fmt3), fmtty3)\n | Open_box (Format (fmt1, str)) ->\n let Fmt_fmtty_EBB (fmt2, fmtty2) = type_format_gen fmt1 fmtty0 in\n let Fmt_fmtty_EBB (fmt3, fmtty3) = type_format_gen fmt0 fmtty2 in\n Fmt_fmtty_EBB (Formatting_gen (Open_box (Format (fmt2, str)), fmt3), fmtty3)\n\n(* Type an Ignored_param node according to an fmtty. *)\nand type_ignored_param : type p q x y z t u v a b c d e f .\n (x, y, z, t, q, p) ignored ->\n (p, y, z, q, u, v) fmt ->\n (a, b, c, d, e, f) fmtty ->\n (a, b, c, d, e, f) fmt_fmtty_ebb =\nfun ign fmt fmtty -> match ign with\n | Ignored_char as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_caml_char as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_string _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_caml_string _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_int _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_int32 _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_nativeint _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_int64 _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_float _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_bool as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_scan_char_set _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_scan_get_counter _ as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_scan_next_char as ign' -> type_ignored_param_one ign' fmt fmtty\n | Ignored_format_arg (pad_opt, sub_fmtty) ->\n type_ignored_param_one (Ignored_format_arg (pad_opt, sub_fmtty)) fmt fmtty\n | Ignored_format_subst (pad_opt, sub_fmtty) ->\n let Fmtty_fmt_EBB (sub_fmtty', Fmt_fmtty_EBB (fmt', fmtty')) =\n type_ignored_format_substitution sub_fmtty fmt fmtty in\n Fmt_fmtty_EBB (Ignored_param (Ignored_format_subst (pad_opt, sub_fmtty'), fmt'), fmtty')\n | Ignored_reader -> (\n match fmtty with\n | Ignored_reader_ty fmtty_rest ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt fmtty_rest in\n Fmt_fmtty_EBB (Ignored_param (Ignored_reader, fmt'), fmtty')\n | _ -> raise Type_mismatch\n )\n\nand type_ignored_param_one : type a1 a2 b1 b2 c1 c2 d1 d2 e1 e2 f1 f2 .\n (a2, b2, c2, d2, d2, a2) ignored ->\n (a1, b1, c1, d1, e1, f1) fmt ->\n (a2, b2, c2, d2, e2, f2) fmtty ->\n (a2, b2, c2, d2, e2, f2) fmt_fmtty_ebb\n= fun ign fmt fmtty ->\n let Fmt_fmtty_EBB (fmt', fmtty') = type_format_gen fmt fmtty in\n Fmt_fmtty_EBB (Ignored_param (ign, fmt'), fmtty')\n\n(* Typing of the complex case: \"%_(...%)\". *)\nand type_ignored_format_substitution : type w x y z p s t u a b c d e f .\n (w, x, y, z, s, p) fmtty ->\n (p, x, y, s, t, u) fmt ->\n (a, b, c, d, e, f) fmtty -> (a, b, c, d, e, f) fmtty_fmt_ebb =\nfun sub_fmtty fmt fmtty -> match sub_fmtty, fmtty with\n | Char_ty sub_fmtty_rest, Char_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Char_ty sub_fmtty_rest', fmt')\n | String_ty sub_fmtty_rest, String_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (String_ty sub_fmtty_rest', fmt')\n | Int_ty sub_fmtty_rest, Int_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Int_ty sub_fmtty_rest', fmt')\n | Int32_ty sub_fmtty_rest, Int32_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Int32_ty sub_fmtty_rest', fmt')\n | Nativeint_ty sub_fmtty_rest, Nativeint_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Nativeint_ty sub_fmtty_rest', fmt')\n | Int64_ty sub_fmtty_rest, Int64_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Int64_ty sub_fmtty_rest', fmt')\n | Float_ty sub_fmtty_rest, Float_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Float_ty sub_fmtty_rest', fmt')\n | Bool_ty sub_fmtty_rest, Bool_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Bool_ty sub_fmtty_rest', fmt')\n | Alpha_ty sub_fmtty_rest, Alpha_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Alpha_ty sub_fmtty_rest', fmt')\n | Theta_ty sub_fmtty_rest, Theta_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Theta_ty sub_fmtty_rest', fmt')\n | Reader_ty sub_fmtty_rest, Reader_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Reader_ty sub_fmtty_rest', fmt')\n | Ignored_reader_ty sub_fmtty_rest, Ignored_reader_ty fmtty_rest ->\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Ignored_reader_ty sub_fmtty_rest', fmt')\n\n | Format_arg_ty (sub2_fmtty, sub_fmtty_rest),\n Format_arg_ty (sub2_fmtty', fmtty_rest) ->\n if Fmtty_EBB sub2_fmtty <> Fmtty_EBB sub2_fmtty' then raise Type_mismatch;\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution sub_fmtty_rest fmt fmtty_rest in\n Fmtty_fmt_EBB (Format_arg_ty (sub2_fmtty', sub_fmtty_rest'), fmt')\n | Format_subst_ty (sub1_fmtty, sub2_fmtty, sub_fmtty_rest),\n Format_subst_ty (sub1_fmtty', sub2_fmtty', fmtty_rest) ->\n (* TODO define Fmtty_rel_EBB to remove those erase_rel *)\n if Fmtty_EBB (erase_rel sub1_fmtty) <> Fmtty_EBB (erase_rel sub1_fmtty') then raise Type_mismatch;\n if Fmtty_EBB (erase_rel sub2_fmtty) <> Fmtty_EBB (erase_rel sub2_fmtty') then raise Type_mismatch;\n let sub_fmtty' = trans (symm sub1_fmtty') sub2_fmtty' in\n let _, f2, _, f4 = fmtty_rel_det sub_fmtty' in\n let Refl = f2 Refl in\n let Refl = f4 Refl in\n let Fmtty_fmt_EBB (sub_fmtty_rest', fmt') =\n type_ignored_format_substitution (erase_rel sub_fmtty_rest) fmt fmtty_rest in\n Fmtty_fmt_EBB (Format_subst_ty (sub1_fmtty', sub2_fmtty', symm sub_fmtty_rest'), fmt')\n | End_of_fmtty, fmtty ->\n Fmtty_fmt_EBB (End_of_fmtty, type_format_gen fmt fmtty)\n | _ -> raise Type_mismatch\n\n(* This implementation of `recast` is a bit disappointing. The\n invariant provided by the type are very strong: the input format's\n type is in relation to the output type's as witnessed by the\n fmtty_rel argument. One would at first expect this function to be\n total, and implementable by exhaustive pattern matching. Instead,\n we reuse the highly partial and much less well-defined function\n `type_format` that has lost all knowledge of the correspondence\n between the argument's types.\n\n Besides the fact that this function reuses a lot of the\n `type_format` logic (eg.: seeing Int_ty in the fmtty parameter does\n not let you match on Int only, as you may in fact have Float\n (Arg_padding, ...) (\"%.*d\") beginning with an Int_ty), it is also\n a partial function, because the typing information in a format is\n not quite enough to reconstruct it unambiguously. For example, the\n format types of \"%d%_r\" and \"%_r%d\" have the same format6\n parameters, but they are not at all exchangeable, and putting one\n in place of the other must result in a dynamic failure.\n\n Given that:\n - we'd have to duplicate a lot of non-trivial typing logic from type_format\n - this wouldn't even eliminate (all) the dynamic failures\n we decided to just reuse type_format directly for now.\n*)\nlet recast :\n type a1 b1 c1 d1 e1 f1\n a2 b2 c2 d2 e2 f2\n .\n (a1, b1, c1, d1, e1, f1) fmt\n -> (a1, b1, c1, d1, e1, f1,\n a2, b2, c2, d2, e2, f2) fmtty_rel\n -> (a2, b2, c2, d2, e2, f2) fmt\n= fun fmt fmtty ->\n type_format fmt (erase_rel (symm fmtty))\n\n(******************************************************************************)\n (* Printing tools *)\n\n(* Add padding spaces arround a string. *)\nlet fix_padding padty width str =\n let len = String.length str in\n let width, padty =\n abs width,\n (* while literal padding widths are always non-negative,\n dynamically-set widths (Arg_padding, eg. %*d) may be negative;\n we interpret those as specifying a padding-to-the-left; this\n means that '0' may get dropped even if it was explicitly set,\n but:\n - this is what the legacy implementation does, and\n we preserve compatibility if possible\n - we could only signal this issue by failing at runtime,\n which is not very nice... *)\n if width < 0 then Left else padty in\n if width <= len then str else\n let res = Bytes.make width (if padty = Zeros then '0' else ' ') in\n begin match padty with\n | Left -> String.blit str 0 res 0 len\n | Right -> String.blit str 0 res (width - len) len\n | Zeros when len > 0 && (str.[0] = '+' || str.[0] = '-' || str.[0] = ' ') ->\n Bytes.set res 0 str.[0];\n String.blit str 1 res (width - len + 1) (len - 1)\n | Zeros when len > 1 && str.[0] = '0' && (str.[1] = 'x' || str.[1] = 'X') ->\n Bytes.set res 1 str.[1];\n String.blit str 2 res (width - len + 2) (len - 2)\n | Zeros ->\n String.blit str 0 res (width - len) len\n end;\n Bytes.unsafe_to_string res\n\n(* Add '0' padding to int, int32, nativeint or int64 string representation. *)\nlet fix_int_precision prec str =\n let prec = abs prec in\n let len = String.length str in\n match str.[0] with\n | ('+' | '-' | ' ') as c when prec + 1 > len ->\n let res = Bytes.make (prec + 1) '0' in\n Bytes.set res 0 c;\n String.blit str 1 res (prec - len + 2) (len - 1);\n Bytes.unsafe_to_string res\n | '0' when prec + 2 > len && len > 1 && (str.[1] = 'x' || str.[1] = 'X') ->\n let res = Bytes.make (prec + 2) '0' in\n Bytes.set res 1 str.[1];\n String.blit str 2 res (prec - len + 4) (len - 2);\n Bytes.unsafe_to_string res\n | '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' when prec > len ->\n let res = Bytes.make prec '0' in\n String.blit str 0 res (prec - len) len;\n Bytes.unsafe_to_string res\n | _ ->\n str\n\n(* Escape a string according to the OCaml lexing convention. *)\nlet string_to_caml_string str =\n String.concat (String.escaped str) [\"\\\"\"; \"\\\"\"]\n\n(* Generate the format_int first argument from an int_conv. *)\nlet format_of_iconv iconv = match iconv with\n | Int_d -> \"%d\" | Int_pd -> \"%+d\" | Int_sd -> \"% d\"\n | Int_i -> \"%i\" | Int_pi -> \"%+i\" | Int_si -> \"% i\"\n | Int_x -> \"%x\" | Int_Cx -> \"%#x\"\n | Int_X -> \"%X\" | Int_CX -> \"%#X\"\n | Int_o -> \"%o\" | Int_Co -> \"%#o\"\n | Int_u -> \"%u\"\n\n(* Generate the format_int32, format_nativeint and format_int64 first\n argument from an int_conv. *)\nlet format_of_aconv iconv c =\n let seps = match iconv with\n | Int_d -> [\"%\";\"d\"] | Int_pd -> [\"%+\";\"d\"] | Int_sd -> [\"% \";\"d\"]\n | Int_i -> [\"%\";\"i\"] | Int_pi -> [\"%+\";\"i\"] | Int_si -> [\"% \";\"i\"]\n | Int_x -> [\"%\";\"x\"] | Int_Cx -> [\"%#\";\"x\"]\n | Int_X -> [\"%\";\"X\"] | Int_CX -> [\"%#\";\"X\"]\n | Int_o -> [\"%\";\"o\"] | Int_Co -> [\"%#\";\"o\"]\n | Int_u -> [\"%\";\"u\"]\n in String.concat (String.make 1 c) seps\n\n(* Generate the format_float first argument form a float_conv. *)\nlet format_of_fconv fconv prec =\n if fconv = Float_F then \"%.12g\" else\n let prec = abs prec in\n let symb = char_of_fconv fconv in\n let buf = buffer_create 16 in\n buffer_add_char buf '%';\n bprint_fconv_flag buf fconv;\n buffer_add_char buf '.';\n buffer_add_string buf (string_of_int prec);\n buffer_add_char buf symb;\n buffer_contents buf\n\n(* Convert an integer to a string according to a conversion. *)\nlet convert_int iconv n = format_int (format_of_iconv iconv) n\nlet convert_int32 iconv n = format_int32 (format_of_aconv iconv 'l') n\nlet convert_nativeint iconv n = format_nativeint (format_of_aconv iconv 'n') n\nlet convert_int64 iconv n = format_int64 (format_of_aconv iconv 'L') n\n\n(* Convert a float to string. *)\n(* Fix special case of \"OCaml float format\". *)\nlet convert_float fconv prec x =\n let prec = abs prec in\n let str = format_float (format_of_fconv fconv prec) x in\n if fconv <> Float_F then str else\n let len = String.length str in\n let rec is_valid i =\n if i = len then false else\n match str.[i] with\n | '.' | 'e' | 'E' -> true\n | _ -> is_valid (i + 1)\n in\n match classify_float x with\n | FP_normal | FP_subnormal | FP_zero ->\n if is_valid 0 then str else str ^ \".\"\n | FP_infinite ->\n if x < 0.0 then \"neg_infinity\" else \"infinity\"\n | FP_nan -> \"nan\"\n\n(* Convert a char to a string according to the OCaml lexical convention. *)\nlet format_caml_char c =\n String.concat (Char.escaped c) [\"'\"; \"'\"]\n\n(* Convert a format type to string *)\nlet string_of_fmtty fmtty =\n let buf = buffer_create 16 in\n bprint_fmtty buf fmtty;\n buffer_contents buf\n\n(******************************************************************************)\n (* Generic printing function *)\n\n(* Make a generic printing function. *)\n(* Used to generate Printf and Format printing functions. *)\n(* Parameters:\n k: a continuation finally applied to the output stream and the accumulator.\n o: the output stream (see k, %a and %t).\n acc: rev list of printing entities (string, char, flush, formatting, ...).\n fmt: the format. *)\nlet rec make_printf : type a b c d e f .\n (b -> (b, c) acc -> f) -> b -> (b, c) acc ->\n (a, b, c, d, e, f) fmt -> a =\nfun k o acc fmt -> match fmt with\n | Char rest ->\n fun c ->\n let new_acc = Acc_data_char (acc, c) in\n make_printf k o new_acc rest\n | Caml_char rest ->\n fun c ->\n let new_acc = Acc_data_string (acc, format_caml_char c) in\n make_printf k o new_acc rest\n | String (pad, rest) ->\n make_string_padding k o acc rest pad (fun str -> str)\n | Caml_string (pad, rest) ->\n make_string_padding k o acc rest pad string_to_caml_string\n | Int (iconv, pad, prec, rest) ->\n make_int_padding_precision k o acc rest pad prec convert_int iconv\n | Int32 (iconv, pad, prec, rest) ->\n make_int_padding_precision k o acc rest pad prec convert_int32 iconv\n | Nativeint (iconv, pad, prec, rest) ->\n make_int_padding_precision k o acc rest pad prec convert_nativeint iconv\n | Int64 (iconv, pad, prec, rest) ->\n make_int_padding_precision k o acc rest pad prec convert_int64 iconv\n | Float (fconv, pad, prec, rest) ->\n make_float_padding_precision k o acc rest pad prec fconv\n | Bool rest ->\n fun b -> make_printf k o (Acc_data_string (acc, string_of_bool b)) rest\n | Alpha rest ->\n fun f x -> make_printf k o (Acc_delay (acc, fun o -> f o x)) rest\n | Theta rest ->\n fun f -> make_printf k o (Acc_delay (acc, f)) rest\n | Custom (arity, f, rest) ->\n make_custom k o acc rest arity (f ())\n | Reader _ ->\n (* This case is impossible, by typing of formats. *)\n (* Indeed, since printf and co. take a format4 as argument, the 'd and 'e\n type parameters of fmt are obviously equals. The Reader is the\n only constructor which touch 'd and 'e type parameters of the format\n type, it adds an (->) to the 'd parameters. Consequently, a format4\n cannot contain a Reader node, except in the sub-format associated to\n an %{...%}. It's not a problem because make_printf do not call\n itself recursively on the sub-format associated to %{...%}. *)\n assert false\n | Flush rest ->\n make_printf k o (Acc_flush acc) rest\n\n | String_literal (str, rest) ->\n make_printf k o (Acc_string_literal (acc, str)) rest\n | Char_literal (chr, rest) ->\n make_printf k o (Acc_char_literal (acc, chr)) rest\n\n | Format_arg (_, sub_fmtty, rest) ->\n let ty = string_of_fmtty sub_fmtty in\n (fun str ->\n ignore str;\n make_printf k o (Acc_data_string (acc, ty)) rest)\n | Format_subst (_, fmtty, rest) ->\n fun (Format (fmt, _)) -> make_printf k o acc\n (concat_fmt (recast fmt fmtty) rest)\n\n | Scan_char_set (_, _, rest) ->\n let new_acc = Acc_invalid_arg (acc, \"Printf: bad conversion %[\") in\n fun _ -> make_printf k o new_acc rest\n | Scan_get_counter (_, rest) ->\n (* This case should be refused for Printf. *)\n (* Accepted for backward compatibility. *)\n (* Interpret %l, %n and %L as %u. *)\n fun n ->\n let new_acc = Acc_data_string (acc, format_int \"%u\" n) in\n make_printf k o new_acc rest\n | Scan_next_char rest ->\n fun c ->\n let new_acc = Acc_data_char (acc, c) in\n make_printf k o new_acc rest\n | Ignored_param (ign, rest) ->\n make_ignored_param k o acc ign rest\n\n | Formatting_lit (fmting_lit, rest) ->\n make_printf k o (Acc_formatting_lit (acc, fmting_lit)) rest\n | Formatting_gen (Open_tag (Format (fmt', _)), rest) ->\n let k' koc kacc =\n make_printf k koc (Acc_formatting_gen (acc, Acc_open_tag kacc)) rest in\n make_printf k' o End_of_acc fmt'\n | Formatting_gen (Open_box (Format (fmt', _)), rest) ->\n let k' koc kacc =\n make_printf k koc (Acc_formatting_gen (acc, Acc_open_box kacc)) rest in\n make_printf k' o End_of_acc fmt'\n\n | End_of_format ->\n k o acc\n\n(* Delay the error (Invalid_argument \"Printf: bad conversion %_\"). *)\n(* Generate functions to take remaining arguments (after the \"%_\"). *)\nand make_ignored_param : type x y a b c d e f .\n (b -> (b, c) acc -> f) -> b -> (b, c) acc ->\n (a, b, c, d, y, x) ignored ->\n (x, b, c, y, e, f) fmt -> a =\nfun k o acc ign fmt -> match ign with\n | Ignored_char -> make_invalid_arg k o acc fmt\n | Ignored_caml_char -> make_invalid_arg k o acc fmt\n | Ignored_string _ -> make_invalid_arg k o acc fmt\n | Ignored_caml_string _ -> make_invalid_arg k o acc fmt\n | Ignored_int (_, _) -> make_invalid_arg k o acc fmt\n | Ignored_int32 (_, _) -> make_invalid_arg k o acc fmt\n | Ignored_nativeint (_, _) -> make_invalid_arg k o acc fmt\n | Ignored_int64 (_, _) -> make_invalid_arg k o acc fmt\n | Ignored_float (_, _) -> make_invalid_arg k o acc fmt\n | Ignored_bool -> make_invalid_arg k o acc fmt\n | Ignored_format_arg _ -> make_invalid_arg k o acc fmt\n | Ignored_format_subst (_, fmtty) -> make_from_fmtty k o acc fmtty fmt\n | Ignored_reader -> assert false\n | Ignored_scan_char_set _ -> make_invalid_arg k o acc fmt\n | Ignored_scan_get_counter _ -> make_invalid_arg k o acc fmt\n | Ignored_scan_next_char -> make_invalid_arg k o acc fmt\n\n\n(* Special case of printf \"%_(\". *)\nand make_from_fmtty : type x y a b c d e f .\n (b -> (b, c) acc -> f) -> b -> (b, c) acc ->\n (a, b, c, d, y, x) fmtty ->\n (x, b, c, y, e, f) fmt -> a =\nfun k o acc fmtty fmt -> match fmtty with\n | Char_ty rest -> fun _ -> make_from_fmtty k o acc rest fmt\n | String_ty rest -> fun _ -> make_from_fmtty k o acc rest fmt\n | Int_ty rest -> fun _ -> make_from_fmtty k o acc rest fmt\n | Int32_ty rest -> fun _ -> make_from_fmtty k o acc rest fmt\n | Nativeint_ty rest -> fun _ -> make_from_fmtty k o acc rest fmt\n | Int64_ty rest -> fun _ -> make_from_fmtty k o acc rest fmt\n | Float_ty rest -> fun _ -> make_from_fmtty k o acc rest fmt\n | Bool_ty rest -> fun _ -> make_from_fmtty k o acc rest fmt\n | Alpha_ty rest -> fun _ _ -> make_from_fmtty k o acc rest fmt\n | Theta_ty rest -> fun _ -> make_from_fmtty k o acc rest fmt\n | Any_ty rest -> fun _ -> make_from_fmtty k o acc rest fmt\n | Reader_ty _ -> assert false\n | Ignored_reader_ty _ -> assert false\n | Format_arg_ty (_, rest) -> fun _ -> make_from_fmtty k o acc rest fmt\n | End_of_fmtty -> make_invalid_arg k o acc fmt\n | Format_subst_ty (ty1, ty2, rest) ->\n let ty = trans (symm ty1) ty2 in\n fun _ -> make_from_fmtty k o acc (concat_fmtty ty rest) fmt\n\n(* Insert an Acc_invalid_arg in the accumulator and continue to generate\n closures to get the remaining arguments. *)\nand make_invalid_arg : type a b c d e f .\n (b -> (b, c) acc -> f) -> b -> (b, c) acc ->\n (a, b, c, d, e, f) fmt -> a =\nfun k o acc fmt ->\n make_printf k o (Acc_invalid_arg (acc, \"Printf: bad conversion %_\")) fmt\n\n(* Fix padding, take it as an extra integer argument if needed. *)\nand make_string_padding : type x z a b c d e f .\n (b -> (b, c) acc -> f) -> b -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (x, z -> a) padding -> (z -> string) -> x =\n fun k o acc fmt pad trans -> match pad with\n | No_padding ->\n fun x ->\n let new_acc = Acc_data_string (acc, trans x) in\n make_printf k o new_acc fmt\n | Lit_padding (padty, width) ->\n fun x ->\n let new_acc = Acc_data_string (acc, fix_padding padty width (trans x)) in\n make_printf k o new_acc fmt\n | Arg_padding padty ->\n fun w x ->\n let new_acc = Acc_data_string (acc, fix_padding padty w (trans x)) in\n make_printf k o new_acc fmt\n\n(* Fix padding and precision for int, int32, nativeint or int64. *)\n(* Take one or two extra integer arguments if needed. *)\nand make_int_padding_precision : type x y z a b c d e f .\n (b -> (b, c) acc -> f) -> b -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (x, y) padding -> (y, z -> a) precision -> (int_conv -> z -> string) ->\n int_conv -> x =\n fun k o acc fmt pad prec trans iconv -> match pad, prec with\n | No_padding, No_precision ->\n fun x ->\n let str = trans iconv x in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | No_padding, Lit_precision p ->\n fun x ->\n let str = fix_int_precision p (trans iconv x) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | No_padding, Arg_precision ->\n fun p x ->\n let str = fix_int_precision p (trans iconv x) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), No_precision ->\n fun x ->\n let str = fix_padding padty w (trans iconv x) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), Lit_precision p ->\n fun x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), Arg_precision ->\n fun p x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, No_precision ->\n fun w x ->\n let str = fix_padding padty w (trans iconv x) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, Lit_precision p ->\n fun w x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, Arg_precision ->\n fun w p x ->\n let str = fix_padding padty w (fix_int_precision p (trans iconv x)) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n\n(* Convert a float, fix padding and precision if needed. *)\n(* Take the float argument and one or two extra integer arguments if needed. *)\nand make_float_padding_precision : type x y a b c d e f .\n (b -> (b, c) acc -> f) -> b -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (x, y) padding -> (y, float -> a) precision -> float_conv -> x =\n fun k o acc fmt pad prec fconv -> match pad, prec with\n | No_padding, No_precision ->\n fun x ->\n let str = convert_float fconv default_float_precision x in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | No_padding, Lit_precision p ->\n fun x ->\n let str = convert_float fconv p x in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | No_padding, Arg_precision ->\n fun p x ->\n let str = convert_float fconv p x in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), No_precision ->\n fun x ->\n let str = convert_float fconv default_float_precision x in\n let str' = fix_padding padty w str in\n make_printf k o (Acc_data_string (acc, str')) fmt\n | Lit_padding (padty, w), Lit_precision p ->\n fun x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | Lit_padding (padty, w), Arg_precision ->\n fun p x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, No_precision ->\n fun w x ->\n let str = convert_float fconv default_float_precision x in\n let str' = fix_padding padty w str in\n make_printf k o (Acc_data_string (acc, str')) fmt\n | Arg_padding padty, Lit_precision p ->\n fun w x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n | Arg_padding padty, Arg_precision ->\n fun w p x ->\n let str = fix_padding padty w (convert_float fconv p x) in\n make_printf k o (Acc_data_string (acc, str)) fmt\n\nand make_custom : type x y a b c d e f .\n (b -> (b, c) acc -> f) -> b -> (b, c) acc ->\n (a, b, c, d, e, f) fmt ->\n (a, x, y) custom_arity -> x -> y =\n fun k o acc rest arity f -> match arity with\n | Custom_zero -> make_printf k o (Acc_data_string (acc, f)) rest\n | Custom_succ arity ->\n fun x ->\n make_custom k o acc rest arity (f x)\n\n(******************************************************************************)\n (* Continuations for make_printf *)\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in an output_stream. *)\n(* Used as a continuation of make_printf. *)\nlet rec output_acc o acc = match acc with\n | Acc_formatting_lit (p, fmting_lit) ->\n let s = string_of_formatting_lit fmting_lit in\n output_acc o p; output_string o s;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n output_acc o p; output_string o \"@{\"; output_acc o acc';\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n output_acc o p; output_string o \"@[\"; output_acc o acc';\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> output_acc o p; output_string o s\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> output_acc o p; output_char o c\n | Acc_delay (p, f) -> output_acc o p; f o\n | Acc_flush p -> output_acc o p; flush o\n | Acc_invalid_arg (p, msg) -> output_acc o p; invalid_arg msg;\n | End_of_acc -> ()\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in a buffer. *)\n(* Used as a continuation of make_printf. *)\nlet rec bufput_acc b acc = match acc with\n | Acc_formatting_lit (p, fmting_lit) ->\n let s = string_of_formatting_lit fmting_lit in\n bufput_acc b p; Buffer.add_string b s;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n bufput_acc b p; Buffer.add_string b \"@{\"; bufput_acc b acc';\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n bufput_acc b p; Buffer.add_string b \"@[\"; bufput_acc b acc';\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> bufput_acc b p; Buffer.add_string b s\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> bufput_acc b p; Buffer.add_char b c\n | Acc_delay (p, f) -> bufput_acc b p; f b\n | Acc_flush p -> bufput_acc b p;\n | Acc_invalid_arg (p, msg) -> bufput_acc b p; invalid_arg msg;\n | End_of_acc -> ()\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in a buffer. *)\n(* Differ from bufput_acc by the interpretation of %a and %t. *)\n(* Used as a continuation of make_printf. *)\nlet rec strput_acc b acc = match acc with\n | Acc_formatting_lit (p, fmting_lit) ->\n let s = string_of_formatting_lit fmting_lit in\n strput_acc b p; Buffer.add_string b s;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n strput_acc b p; Buffer.add_string b \"@{\"; strput_acc b acc';\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n strput_acc b p; Buffer.add_string b \"@[\"; strput_acc b acc';\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> strput_acc b p; Buffer.add_string b s\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> strput_acc b p; Buffer.add_char b c\n | Acc_delay (p, f) -> strput_acc b p; Buffer.add_string b (f ())\n | Acc_flush p -> strput_acc b p;\n | Acc_invalid_arg (p, msg) -> strput_acc b p; invalid_arg msg;\n | End_of_acc -> ()\n\n(******************************************************************************)\n (* Error managment *)\n\n(* Raise a Failure with a pretty-printed error message. *)\nlet failwith_message (Format (fmt, _)) =\n let buf = Buffer.create 256 in\n let k () acc = strput_acc buf acc; failwith (Buffer.contents buf) in\n make_printf k () End_of_acc fmt\n\n(******************************************************************************)\n (* Formatting tools *)\n\n(* Convert a string to an open block description (indent, block_type) *)\nlet open_box_of_string str =\n if str = \"\" then (0, Pp_box) else\n let len = String.length str in\n let invalid_box () = failwith_message \"invalid box description %S\" str in\n let rec parse_spaces i =\n if i = len then i else\n match str.[i] with\n | ' ' | '\\t' -> parse_spaces (i + 1)\n | _ -> i\n and parse_lword i j =\n if j = len then j else\n match str.[j] with\n | 'a' .. 'z' -> parse_lword i (j + 1)\n | _ -> j\n and parse_int i j =\n if j = len then j else\n match str.[j] with\n | '0' .. '9' | '-' -> parse_int i (j + 1)\n | _ -> j in\n let wstart = parse_spaces 0 in\n let wend = parse_lword wstart wstart in\n let box_name = String.sub str wstart (wend - wstart) in\n let nstart = parse_spaces wend in\n let nend = parse_int nstart nstart in\n let indent =\n if nstart = nend then 0 else\n try int_of_string (String.sub str nstart (nend - nstart))\n with Failure _ -> invalid_box () in\n let exp_end = parse_spaces nend in\n let () = if exp_end <> len then invalid_box () in\n let box_type = match box_name with\n | \"\" | \"b\" -> Pp_box\n | \"h\" -> Pp_hbox\n | \"v\" -> Pp_vbox\n | \"hv\" -> Pp_hvbox\n | \"hov\" -> Pp_hovbox\n | _ -> invalid_box () in\n (indent, box_type)\n\n(******************************************************************************)\n (* Parsing tools *)\n\n(* Create a padding_fmt_ebb from a padding and a format. *)\n(* Copy the padding to disjoin the type parameters of argument and result. *)\nlet make_padding_fmt_ebb : type x y .\n (x, y) padding -> (_, _, _, _, _, _) fmt ->\n (_, _, _, _, _) padding_fmt_ebb =\nfun pad fmt -> match pad with\n | No_padding -> Padding_fmt_EBB (No_padding, fmt)\n | Lit_padding (s, w) -> Padding_fmt_EBB (Lit_padding (s, w), fmt)\n | Arg_padding s -> Padding_fmt_EBB (Arg_padding s, fmt)\n\n(* Create a precision_fmt_ebb from a precision and a format. *)\n(* Copy the precision to disjoin the type parameters of argument and result. *)\nlet make_precision_fmt_ebb : type x y .\n (x, y) precision -> (_, _, _, _, _, _) fmt ->\n (_, _, _, _, _) precision_fmt_ebb =\nfun prec fmt -> match prec with\n | No_precision -> Precision_fmt_EBB (No_precision, fmt)\n | Lit_precision p -> Precision_fmt_EBB (Lit_precision p, fmt)\n | Arg_precision -> Precision_fmt_EBB (Arg_precision, fmt)\n\n(* Create a padprec_fmt_ebb forma a padding, a precision and a format. *)\n(* Copy the padding and the precision to disjoin type parameters of arguments\n and result. *)\nlet make_padprec_fmt_ebb : type x y z t .\n (x, y) padding -> (z, t) precision ->\n (_, _, _, _, _, _) fmt ->\n (_, _, _, _, _) padprec_fmt_ebb =\nfun pad prec fmt ->\n let Precision_fmt_EBB (prec, fmt') = make_precision_fmt_ebb prec fmt in\n match pad with\n | No_padding -> Padprec_fmt_EBB (No_padding, prec, fmt')\n | Lit_padding (s, w) -> Padprec_fmt_EBB (Lit_padding (s, w), prec, fmt')\n | Arg_padding s -> Padprec_fmt_EBB (Arg_padding s, prec, fmt')\n\n(******************************************************************************)\n (* Format parsing *)\n\n(* Parse a string representing a format and create a fmt_ebb. *)\n(* Raise an Failure exception in case of invalid format. *)\nlet fmt_ebb_of_string ?legacy_behavior str =\n (* Parameters naming convention: *)\n (* - lit_start: start of the literal sequence. *)\n (* - str_ind: current index in the string. *)\n (* - end_ind: end of the current (sub-)format. *)\n (* - pct_ind: index of the '%' in the current micro-format. *)\n (* - zero: is the '0' flag defined in the current micro-format. *)\n (* - minus: is the '-' flag defined in the current micro-format. *)\n (* - plus: is the '+' flag defined in the current micro-format. *)\n (* - sharp: is the '#' flag defined in the current micro-format. *)\n (* - space: is the ' ' flag defined in the current micro-format. *)\n (* - ign: is the '_' flag defined in the current micro-format. *)\n (* - pad: padding of the current micro-format. *)\n (* - prec: precision of the current micro-format. *)\n (* - symb: char representing the conversion ('c', 's', 'd', ...). *)\n (* - char_set: set of characters as bitmap (see scanf %[...]). *)\n\n let legacy_behavior = match legacy_behavior with\n | Some flag -> flag\n | None -> true\n (* When this flag is enabled, the format parser tries to behave as\n the <4.02 implementations, in particular it ignores most benine\n nonsensical format. When the flag is disabled, it will reject any\n format that is not accepted by the specification.\n\n A typical example would be \"%+ d\": specifying both '+' (if the\n number is positive, pad with a '+' to get the same width as\n negative numbres) and ' ' (if the number is positive, pad with\n a space) does not make sense, but the legacy (< 4.02)\n implementation was happy to just ignore the space.\n *)\n in\n\n (* Raise a Failure with a friendly error message. *)\n let invalid_format_message str_ind msg =\n failwith_message\n \"invalid format %S: at character number %d, %s\"\n str str_ind msg;\n in\n\n (* Used when the end of the format (or the current sub-format) was encoutered\n unexpectedly. *)\n let unexpected_end_of_format end_ind =\n invalid_format_message end_ind\n \"unexpected end of format\"\n in\n\n (* Used for %0c: no other widths are implemented *)\n let invalid_nonnull_char_width str_ind =\n invalid_format_message str_ind\n \"non-zero widths are unsupported for %c conversions\"\n in\n (* Raise Failure with a friendly error message about an option dependencie\n problem. *)\n let invalid_format_without str_ind c s =\n failwith_message\n \"invalid format %S: at character number %d, '%c' without %s\"\n str str_ind c s\n in\n\n (* Raise Failure with a friendly error message about an unexpected\n character. *)\n let expected_character str_ind expected read =\n failwith_message\n \"invalid format %S: at character number %d, %s expected, read %C\"\n str str_ind expected read\n in\n\n (* Parse the string from beg_ind (included) to end_ind (excluded). *)\n let rec parse : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun beg_ind end_ind -> parse_literal beg_ind beg_ind end_ind\n\n (* Read literal characters up to '%' or '@' special characters. *)\n and parse_literal : type e f . int -> int -> int -> (_, _, e, f) fmt_ebb =\n fun lit_start str_ind end_ind ->\n if str_ind = end_ind then add_literal lit_start str_ind End_of_format else\n match str.[str_ind] with\n | '%' ->\n let Fmt_EBB fmt_rest = parse_format str_ind end_ind in\n add_literal lit_start str_ind fmt_rest\n | '@' ->\n let Fmt_EBB fmt_rest = parse_after_at (str_ind + 1) end_ind in\n add_literal lit_start str_ind fmt_rest\n | _ ->\n parse_literal lit_start (str_ind + 1) end_ind\n\n (* Parse a format after '%' *)\n and parse_format : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun pct_ind end_ind -> parse_ign pct_ind (pct_ind + 1) end_ind\n\n and parse_ign : type e f . int -> int -> int -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '_' -> parse_flags pct_ind (str_ind+1) end_ind true\n | _ -> parse_flags pct_ind str_ind end_ind false\n\n and parse_flags : type e f . int -> int -> int -> bool -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind ign ->\n let zero = ref false and minus = ref false\n and plus = ref false and space = ref false\n and sharp = ref false in\n let set_flag str_ind flag =\n (* in legacy mode, duplicate flags are accepted *)\n if !flag && not legacy_behavior then\n failwith_message\n \"invalid format %S: at character number %d, duplicate flag %C\"\n str str_ind str.[str_ind];\n flag := true;\n in\n let rec read_flags str_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n begin match str.[str_ind] with\n | '0' -> set_flag str_ind zero; read_flags (str_ind + 1)\n | '-' -> set_flag str_ind minus; read_flags (str_ind + 1)\n | '+' -> set_flag str_ind plus; read_flags (str_ind + 1)\n | '#' -> set_flag str_ind sharp; read_flags (str_ind + 1)\n | ' ' -> set_flag str_ind space; read_flags (str_ind + 1)\n | _ ->\n parse_padding pct_ind str_ind end_ind\n !zero !minus !plus !sharp !space ign\n end\n in\n read_flags str_ind\n\n (* Try to read a digital or a '*' padding. *)\n and parse_padding : type e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool -> bool ->\n (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind zero minus plus sharp space ign ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let padty = match zero, minus with\n | false, false -> Right\n | false, true -> Left\n | true, false -> Zeros\n | true, true ->\n if legacy_behavior then Left\n else incompatible_flag pct_ind str_ind '-' \"0\" in\n match str.[str_ind] with\n | '0' .. '9' ->\n let new_ind, width = parse_positive str_ind end_ind 0 in\n parse_after_padding pct_ind new_ind end_ind minus plus sharp space ign\n (Lit_padding (padty, width))\n | '*' ->\n parse_after_padding pct_ind (str_ind + 1) end_ind minus plus sharp space\n ign (Arg_padding padty)\n | _ ->\n begin match padty with\n | Left ->\n if not legacy_behavior then\n invalid_format_without (str_ind - 1) '-' \"padding\";\n parse_after_padding pct_ind str_ind end_ind minus plus sharp space ign\n No_padding\n | Zeros ->\n (* a '0' padding indication not followed by anything should\n be interpreted as a Right padding of width 0. This is used\n by scanning conversions %0s and %0c *)\n parse_after_padding pct_ind str_ind end_ind minus plus sharp space ign\n (Lit_padding (Right, 0))\n | Right ->\n parse_after_padding pct_ind str_ind end_ind minus plus sharp space ign\n No_padding\n end\n\n (* Is precision defined? *)\n and parse_after_padding : type x e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool ->\n (x, _) padding -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind minus plus sharp space ign pad ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '.' ->\n parse_precision pct_ind (str_ind + 1) end_ind minus plus sharp space ign\n pad\n | symb ->\n parse_conversion pct_ind (str_ind + 1) end_ind plus sharp space ign pad\n No_precision pad symb\n\n (* Read the digital or '*' precision. *)\n and parse_precision : type x e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool ->\n (x, _) padding -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind minus plus sharp space ign pad ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let parse_literal minus str_ind =\n let new_ind, prec = parse_positive str_ind end_ind 0 in\n parse_after_precision pct_ind new_ind end_ind minus plus sharp space ign\n pad (Lit_precision prec) in\n match str.[str_ind] with\n | '0' .. '9' -> parse_literal minus str_ind\n | ('+' | '-') as symb when legacy_behavior ->\n (* Legacy mode would accept and ignore '+' or '-' before the\n integer describing the desired precision; not that this\n cannot happen for padding width, as '+' and '-' already have\n a semantics there.\n\n That said, the idea (supported by this tweak) that width and\n precision literals are \"integer literals\" in the OCaml sense is\n still blatantly wrong, as 123_456 or 0xFF are rejected. *)\n parse_literal (minus || symb = '-') (str_ind + 1)\n | '*' ->\n parse_after_precision pct_ind (str_ind + 1) end_ind minus plus sharp space\n ign pad Arg_precision\n | _ ->\n if legacy_behavior then\n (* note that legacy implementation did not ignore '.' without\n a number (as it does for padding indications), but\n interprets it as '.0' *)\n parse_after_precision pct_ind str_ind end_ind minus plus sharp space ign\n pad (Lit_precision 0)\n else\n invalid_format_without (str_ind - 1) '.' \"precision\"\n\n (* Try to read the conversion. *)\n and parse_after_precision : type x y z t e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> bool ->\n (x, y) padding -> (z, t) precision -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind minus plus sharp space ign pad prec ->\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let parse_conv (type u) (type v) (padprec : (u, v) padding) =\n parse_conversion pct_ind (str_ind + 1) end_ind plus sharp space ign pad\n prec padprec str.[str_ind] in\n (* in legacy mode, some formats (%s and %S) accept a weird mix of\n padding and precision, which is merged as a single padding\n information. For example, in %.10s the precision is implicitly\n understood as padding %10s, but the left-padding component may\n be specified either as a left padding or a negative precision:\n %-.3s and %.-3s are equivalent to %-3s *)\n match pad with\n | No_padding -> (\n match minus, prec with\n | _, No_precision -> parse_conv No_padding\n | false, Lit_precision n -> parse_conv (Lit_padding (Right, n))\n | true, Lit_precision n -> parse_conv (Lit_padding (Left, n))\n | false, Arg_precision -> parse_conv (Arg_padding Right)\n | true, Arg_precision -> parse_conv (Arg_padding Left)\n )\n | pad -> parse_conv pad\n\n (* Case analysis on conversion. *)\n and parse_conversion : type x y z t u v e f .\n int -> int -> int -> bool -> bool -> bool -> bool -> (x, y) padding ->\n (z, t) precision -> (u, v) padding -> char -> (_, _, e, f) fmt_ebb =\n fun pct_ind str_ind end_ind plus sharp space ign pad prec padprec symb ->\n (* Flags used to check option usages/compatibilities. *)\n let plus_used = ref false and sharp_used = ref false\n and space_used = ref false and ign_used = ref false\n and pad_used = ref false and prec_used = ref false in\n\n (* Access to options, update flags. *)\n let get_plus () = plus_used := true; plus\n and get_sharp () = sharp_used := true; sharp\n and get_space () = space_used := true; space\n and get_ign () = ign_used := true; ign\n and get_pad () = pad_used := true; pad\n and get_prec () = prec_used := true; prec\n and get_padprec () = pad_used := true; padprec in\n\n (* Check that padty <> Zeros. *)\n let check_no_0 symb (type a) (type b) (pad : (a, b) padding) =\n match pad with\n | No_padding -> pad\n | Lit_padding ((Left | Right), _) -> pad\n | Arg_padding (Left | Right) -> pad\n | Lit_padding (Zeros, width) ->\n if legacy_behavior then Lit_padding (Right, width)\n else incompatible_flag pct_ind str_ind symb \"0\"\n | Arg_padding Zeros ->\n if legacy_behavior then Arg_padding Right\n else incompatible_flag pct_ind str_ind symb \"0\"\n in\n\n (* Get padding as a pad_option (see \"%_\", \"%{\", \"%(\" and \"%[\").\n (no need for legacy mode tweaking, those were rejected by the\n legacy parser as well) *)\n let opt_of_pad c (type a) (type b) (pad : (a, b) padding) = match pad with\n | No_padding -> None\n | Lit_padding (Right, width) -> Some width\n | Lit_padding (Zeros, width) ->\n if legacy_behavior then Some width\n else incompatible_flag pct_ind str_ind c \"'0'\"\n | Lit_padding (Left, width) ->\n if legacy_behavior then Some width\n else incompatible_flag pct_ind str_ind c \"'-'\"\n | Arg_padding _ -> incompatible_flag pct_ind str_ind c \"'*'\"\n in\n let get_pad_opt c = opt_of_pad c (get_pad ()) in\n let get_padprec_opt c = opt_of_pad c (get_padprec ()) in\n\n (* Get precision as a prec_option (see \"%_f\").\n (no need for legacy mode tweaking, those were rejected by the\n legacy parser as well) *)\n let get_prec_opt () = match get_prec () with\n | No_precision -> None\n | Lit_precision ndec -> Some ndec\n | Arg_precision -> incompatible_flag pct_ind str_ind '_' \"'*'\"\n in\n\n let fmt_result = match symb with\n | ',' ->\n parse str_ind end_ind\n | 'c' ->\n let char_format fmt_rest = (* %c *)\n if get_ign ()\n then Fmt_EBB (Ignored_param (Ignored_char, fmt_rest))\n else Fmt_EBB (Char fmt_rest)\n in\n let scan_format fmt_rest = (* %0c *)\n if get_ign ()\n then Fmt_EBB (Ignored_param (Ignored_scan_next_char, fmt_rest))\n else Fmt_EBB (Scan_next_char fmt_rest)\n in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n begin match get_pad_opt 'c' with\n | None -> char_format fmt_rest\n | Some 0 -> scan_format fmt_rest\n | Some _n ->\n\u0009 if not legacy_behavior\n\u0009 then invalid_nonnull_char_width str_ind\n\u0009 else (* legacy ignores %c widths *) char_format fmt_rest\n end\n | 'C' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then Fmt_EBB (Ignored_param (Ignored_caml_char,fmt_rest))\n else Fmt_EBB (Caml_char fmt_rest)\n | 's' ->\n let pad = check_no_0 symb (get_padprec ()) in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_string (get_padprec_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padding_fmt_EBB (pad', fmt_rest') =\n make_padding_fmt_ebb pad fmt_rest in\n Fmt_EBB (String (pad', fmt_rest'))\n | 'S' ->\n let pad = check_no_0 symb (get_padprec ()) in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_caml_string (get_padprec_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padding_fmt_EBB (pad', fmt_rest') =\n make_padding_fmt_ebb pad fmt_rest in\n Fmt_EBB (Caml_string (pad', fmt_rest'))\n | 'd' | 'i' | 'x' | 'X' | 'o' | 'u' ->\n let iconv = compute_int_conv pct_ind str_ind (get_plus ()) (get_sharp ())\n (get_space ()) symb in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_int (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n\u0009(* %5.3d is accepted and meaningful: pad to length 5 with\n\u0009 spaces, but first pad with zeros upto length 3 (0-padding\n\u0009 is the interpretation of \"precision\" for integer formats).\n\n %05.3d is redundant: pad to length 5 *with zeros*, but\n first pad with zeros... To add insult to the injury, the\n legacy implementation ignores the 0-padding indication and\n does the 5 padding with spaces instead. We reuse this\n interpretation for compatiblity, but statically reject this\n format when the legacy mode is disabled, to protect strict\n users from this corner case.\n\u0009 *)\n let pad = match get_pad (), get_prec () with\n | pad, No_precision -> pad\n | No_padding, _ -> No_padding\n | Lit_padding (Zeros, n), _ ->\n if legacy_behavior then Lit_padding (Right, n)\n else incompatible_flag pct_ind str_ind '0' \"precision\"\n | Arg_padding Zeros, _ ->\n if legacy_behavior then Arg_padding Right\n else incompatible_flag pct_ind str_ind '0' \"precision\"\n | Lit_padding _ as pad, _ -> pad\n | Arg_padding _ as pad, _ -> pad in\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb pad (get_prec ()) fmt_rest in\n Fmt_EBB (Int (iconv, pad', prec', fmt_rest'))\n | 'N' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n let counter = Token_counter in\n if get_ign () then\n let ignored = Ignored_scan_get_counter counter in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Scan_get_counter (counter, fmt_rest))\n | 'l' | 'n' | 'L' when str_ind=end_ind || not (is_int_base str.[str_ind]) ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n let counter = counter_of_char symb in\n if get_ign () then\n let ignored = Ignored_scan_get_counter counter in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Scan_get_counter (counter, fmt_rest))\n | 'l' ->\n let iconv =\n compute_int_conv pct_ind (str_ind + 1) (get_plus ()) (get_sharp ())\n (get_space ()) str.[str_ind] in\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n if get_ign () then\n let ignored = Ignored_int32 (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Int32 (iconv, pad', prec', fmt_rest'))\n | 'n' ->\n let iconv =\n compute_int_conv pct_ind (str_ind + 1) (get_plus ())\n (get_sharp ()) (get_space ()) str.[str_ind] in\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n if get_ign () then\n let ignored = Ignored_nativeint (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Nativeint (iconv, pad', prec', fmt_rest'))\n | 'L' ->\n let iconv =\n compute_int_conv pct_ind (str_ind + 1) (get_plus ()) (get_sharp ())\n (get_space ()) str.[str_ind] in\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n if get_ign () then\n let ignored = Ignored_int64 (iconv, get_pad_opt '_') in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Int64 (iconv, pad', prec', fmt_rest'))\n | 'f' | 'e' | 'E' | 'g' | 'G' | 'F' ->\n let fconv = compute_float_conv pct_ind str_ind (get_plus ())\n (get_space ()) symb in\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then\n let ignored = Ignored_float (get_pad_opt '_', get_prec_opt ()) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n let Padprec_fmt_EBB (pad', prec', fmt_rest') =\n make_padprec_fmt_ebb (get_pad ()) (get_prec ()) fmt_rest in\n Fmt_EBB (Float (fconv, pad', prec', fmt_rest'))\n | 'b' | 'B' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then Fmt_EBB (Ignored_param (Ignored_bool, fmt_rest))\n else Fmt_EBB (Bool fmt_rest)\n | 'a' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Alpha fmt_rest)\n | 't' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Theta fmt_rest)\n | 'r' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n if get_ign () then Fmt_EBB (Ignored_param (Ignored_reader, fmt_rest))\n else Fmt_EBB (Reader fmt_rest)\n | '!' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Flush fmt_rest)\n | ('%' | '@') as c ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Char_literal (c, fmt_rest))\n | '{' ->\n let sub_end = search_subformat_end str_ind end_ind '}' in\n let Fmt_EBB sub_fmt = parse str_ind sub_end in\n let Fmt_EBB fmt_rest = parse (sub_end + 2) end_ind in\n let sub_fmtty = fmtty_of_fmt sub_fmt in\n if get_ign () then\n let ignored = Ignored_format_arg (get_pad_opt '_', sub_fmtty) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Format_arg (get_pad_opt '{', sub_fmtty, fmt_rest))\n | '(' ->\n let sub_end = search_subformat_end str_ind end_ind ')' in\n let Fmt_EBB fmt_rest = parse (sub_end + 2) end_ind in\n let Fmt_EBB sub_fmt = parse str_ind sub_end in\n let sub_fmtty = fmtty_of_fmt sub_fmt in\n if get_ign () then\n let ignored = Ignored_format_subst (get_pad_opt '_', sub_fmtty) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Format_subst (get_pad_opt '(', sub_fmtty, fmt_rest))\n | '[' ->\n let next_ind, char_set = parse_char_set str_ind end_ind in\n let Fmt_EBB fmt_rest = parse next_ind end_ind in\n if get_ign () then\n let ignored = Ignored_scan_char_set (get_pad_opt '_', char_set) in\n Fmt_EBB (Ignored_param (ignored, fmt_rest))\n else\n Fmt_EBB (Scan_char_set (get_pad_opt '[', char_set, fmt_rest))\n | '-' | '+' | '#' | ' ' | '_' ->\n failwith_message\n \"invalid format %S: at character number %d, \\\n flag %C is only allowed after the '%%', before padding and precision\"\n str pct_ind symb\n | _ ->\n failwith_message\n \"invalid format %S: at character number %d, \\\n invalid conversion \\\"%%%c\\\"\" str (str_ind - 1) symb\n in\n (* Check for unused options, and reject them as incompatible.\n\n Such checks need to be disabled in legacy mode, as the legacy\n parser silently ignored incompatible flags. *)\n if not legacy_behavior then begin\n if not !plus_used && plus then\n incompatible_flag pct_ind str_ind symb \"'+'\";\n if not !sharp_used && sharp then\n incompatible_flag pct_ind str_ind symb \"'#'\";\n if not !space_used && space then\n incompatible_flag pct_ind str_ind symb \"' '\";\n if not !pad_used && Padding_EBB pad <> Padding_EBB No_padding then\n incompatible_flag pct_ind str_ind symb \"`padding'\";\n if not !prec_used && Precision_EBB prec <> Precision_EBB No_precision then\n incompatible_flag pct_ind str_ind (if ign then '_' else symb)\n \"`precision'\";\n if ign && plus then incompatible_flag pct_ind str_ind '_' \"'+'\";\n end;\n (* this last test must not be disabled in legacy mode,\n as ignoring it would typically result in a different typing\n than what the legacy parser used *)\n if not !ign_used && ign then\n begin match symb with\n (* argument-less formats can safely be ignored in legacy mode *)\n | ('@' | '%' | '!' | ',') when legacy_behavior -> ()\n | _ ->\n incompatible_flag pct_ind str_ind symb \"'_'\"\n end;\n fmt_result\n\n (* Parse formatting informations (after '@'). *)\n and parse_after_at : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun str_ind end_ind ->\n if str_ind = end_ind then Fmt_EBB (Char_literal ('@', End_of_format))\n else\n match str.[str_ind] with\n | '[' ->\n parse_tag false (str_ind + 1) end_ind\n | ']' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Close_box, fmt_rest))\n | '{' ->\n parse_tag true (str_ind + 1) end_ind\n | '}' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Close_tag, fmt_rest))\n | ',' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Break (\"@,\", 0, 0), fmt_rest))\n | ' ' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Break (\"@ \", 1, 0), fmt_rest))\n | ';' ->\n parse_good_break (str_ind + 1) end_ind\n | '?' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (FFlush, fmt_rest))\n | '\\n' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Force_newline, fmt_rest))\n | '.' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Flush_newline, fmt_rest))\n | '<' ->\n parse_magic_size (str_ind + 1) end_ind\n | '@' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Escaped_at, fmt_rest))\n | '%' when str_ind + 1 < end_ind && str.[str_ind + 1] = '%' ->\n let Fmt_EBB fmt_rest = parse (str_ind + 2) end_ind in\n Fmt_EBB (Formatting_lit (Escaped_percent, fmt_rest))\n | '%' ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Char_literal ('@', fmt_rest))\n | c ->\n let Fmt_EBB fmt_rest = parse (str_ind + 1) end_ind in\n Fmt_EBB (Formatting_lit (Scan_indic c, fmt_rest))\n\n and check_open_box : type a b c d e f . (a, b, c, d, e, f) fmt -> unit =\n fun fmt -> match fmt with\n | String_literal (str, End_of_format) -> (\n try ignore (open_box_of_string str) with Failure _ ->\n ((* Emit warning: invalid open box *))\n )\n | _ -> ()\n\n (* Try to read the optionnal after \"@{\" or \"@[\". *)\n and parse_tag : type e f . bool -> int -> int -> (_, _, e, f) fmt_ebb =\n fun is_open_tag str_ind end_ind ->\n try\n if str_ind = end_ind then raise Not_found;\n match str.[str_ind] with\n | '<' ->\n let ind = String.index_from str (str_ind + 1) '>' in\n if ind >= end_ind then raise Not_found;\n let sub_str = String.sub str str_ind (ind - str_ind + 1) in\n let Fmt_EBB fmt_rest = parse (ind + 1) end_ind in\n let Fmt_EBB sub_fmt = parse str_ind (ind + 1) in\n let sub_format = Format (sub_fmt, sub_str) in\n let formatting = if is_open_tag then Open_tag sub_format else (\n check_open_box sub_fmt;\n Open_box sub_format) in\n Fmt_EBB (Formatting_gen (formatting, fmt_rest))\n | _ ->\n raise Not_found\n with Not_found ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n let sub_format = Format (End_of_format, \"\") in\n let formatting =\n if is_open_tag then Open_tag sub_format else Open_box sub_format in\n Fmt_EBB (Formatting_gen (formatting, fmt_rest))\n\n (* Try to read the optionnal after \"@;\". *)\n and parse_good_break : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun str_ind end_ind ->\n let next_ind, formatting_lit =\n try\n if str_ind = end_ind || str.[str_ind] <> '<' then raise Not_found;\n let str_ind_1 = parse_spaces (str_ind + 1) end_ind in\n match str.[str_ind_1] with\n | '0' .. '9' | '-' -> (\n let str_ind_2, width = parse_integer str_ind_1 end_ind in\n let str_ind_3 = parse_spaces str_ind_2 end_ind in\n match str.[str_ind_3] with\n | '>' ->\n let s = String.sub str (str_ind-2) (str_ind_3-str_ind+3) in\n str_ind_3 + 1, Break (s, width, 0)\n | '0' .. '9' | '-' ->\n let str_ind_4, offset = parse_integer str_ind_3 end_ind in\n let str_ind_5 = parse_spaces str_ind_4 end_ind in\n if str.[str_ind_5] <> '>' then raise Not_found;\n let s = String.sub str (str_ind-2) (str_ind_5-str_ind+3) in\n str_ind_5 + 1, Break (s, width, offset)\n | _ -> raise Not_found\n )\n | _ -> raise Not_found\n with Not_found | Failure _ ->\n str_ind, Break (\"@;\", 1, 0)\n in\n let Fmt_EBB fmt_rest = parse next_ind end_ind in\n Fmt_EBB (Formatting_lit (formatting_lit, fmt_rest))\n\n (* Parse the size in a . *)\n and parse_magic_size : type e f . int -> int -> (_, _, e, f) fmt_ebb =\n fun str_ind end_ind ->\n match\n try\n let str_ind_1 = parse_spaces str_ind end_ind in\n match str.[str_ind_1] with\n | '0' .. '9' | '-' ->\n let str_ind_2, size = parse_integer str_ind_1 end_ind in\n let str_ind_3 = parse_spaces str_ind_2 end_ind in\n if str.[str_ind_3] <> '>' then raise Not_found;\n let s = String.sub str (str_ind - 2) (str_ind_3 - str_ind + 3) in\n Some (str_ind_3 + 1, Magic_size (s, size))\n | _ -> None\n with Not_found | Failure _ ->\n None\n with\n | Some (next_ind, formatting_lit) ->\n let Fmt_EBB fmt_rest = parse next_ind end_ind in\n Fmt_EBB (Formatting_lit (formatting_lit, fmt_rest))\n | None ->\n let Fmt_EBB fmt_rest = parse str_ind end_ind in\n Fmt_EBB (Formatting_lit (Scan_indic '<', fmt_rest))\n\n (* Parse and construct a char set. *)\n and parse_char_set str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n\n let char_set = create_char_set () in\n let add_char c =\n add_in_char_set char_set c;\n in\n let add_range c c' =\n for i = int_of_char c to int_of_char c' do\n add_in_char_set char_set (char_of_int i);\n done;\n in\n\n let fail_single_percent str_ind =\n failwith_message\n \"invalid format %S: '%%' alone is not accepted in character sets, \\\n use %%%% instead at position %d.\" str str_ind;\n in\n\n (* Parse the first character of a char set. *)\n let rec parse_char_set_start str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n let c = str.[str_ind] in\n parse_char_set_after_char (str_ind + 1) end_ind c;\n\n (* Parse the content of a char set until the first ']'. *)\n and parse_char_set_content str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | ']' ->\n str_ind + 1\n | '-' ->\n add_char '-';\n parse_char_set_content (str_ind + 1) end_ind;\n | c ->\n parse_char_set_after_char (str_ind + 1) end_ind c;\n\n (* Test for range in char set. *)\n and parse_char_set_after_char str_ind end_ind c =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | ']' ->\n add_char c;\n str_ind + 1\n | '-' ->\n parse_char_set_after_minus (str_ind + 1) end_ind c\n | ('%' | '@') as c' when c = '%' ->\n add_char c';\n parse_char_set_content (str_ind + 1) end_ind\n | c' ->\n if c = '%' then fail_single_percent str_ind;\n (* note that '@' alone is accepted, as done by the legacy implementation;\n the documentation specifically requires %@ so we could warn on that *)\n add_char c;\n parse_char_set_after_char (str_ind + 1) end_ind c'\n\n (* Manage range in char set (except if the '-' the last char before ']') *)\n and parse_char_set_after_minus str_ind end_ind c =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | ']' ->\n add_char c;\n add_char '-';\n str_ind + 1\n | '%' ->\n if str_ind + 1 = end_ind then unexpected_end_of_format end_ind;\n begin match str.[str_ind + 1] with\n | ('%' | '@') as c' ->\n add_range c c';\n parse_char_set_content (str_ind + 2) end_ind\n | _ -> fail_single_percent str_ind\n end\n | c' ->\n add_range c c';\n parse_char_set_content (str_ind + 1) end_ind\n in\n let str_ind, reverse =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '^' -> str_ind + 1, true\n | _ -> str_ind, false in\n let next_ind = parse_char_set_start str_ind end_ind in\n let char_set = freeze_char_set char_set in\n next_ind, (if reverse then rev_char_set char_set else char_set)\n\n (* Consume all next spaces, raise an Failure if end_ind is reached. *)\n and parse_spaces str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n if str.[str_ind] = ' ' then parse_spaces (str_ind + 1) end_ind else str_ind\n\n (* Read a positive integer from the string, raise a Failure if end_ind is\n reached. *)\n and parse_positive str_ind end_ind acc =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '0' .. '9' as c ->\n let new_acc = acc * 10 + (int_of_char c - int_of_char '0') in\n if new_acc > Sys.max_string_length then\n failwith_message\n \"invalid format %S: integer %d is greater than the limit %d\"\n str new_acc Sys.max_string_length\n else\n parse_positive (str_ind + 1) end_ind new_acc\n | _ -> str_ind, acc\n\n (* Read a positive or negative integer from the string, raise a Failure\n if end_ind is reached. *)\n and parse_integer str_ind end_ind =\n if str_ind = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind] with\n | '0' .. '9' -> parse_positive str_ind end_ind 0\n | '-' -> (\n if str_ind + 1 = end_ind then unexpected_end_of_format end_ind;\n match str.[str_ind + 1] with\n | '0' .. '9' ->\n let next_ind, n = parse_positive (str_ind + 1) end_ind 0 in\n next_ind, -n\n | c ->\n expected_character (str_ind + 1) \"digit\" c\n )\n | _ -> assert false\n\n (* Add a literal to a format from a literal character sub-sequence. *)\n and add_literal : type a d e f .\n int -> int -> (a, _, _, d, e, f) fmt ->\n (_, _, e, f) fmt_ebb =\n fun lit_start str_ind fmt -> match str_ind - lit_start with\n | 0 -> Fmt_EBB fmt\n | 1 -> Fmt_EBB (Char_literal (str.[lit_start], fmt))\n | size -> Fmt_EBB (String_literal (String.sub str lit_start size, fmt))\n\n (* Search the end of the current sub-format\n (i.e. the corresponding \"%}\" or \"%)\") *)\n and search_subformat_end str_ind end_ind c =\n if str_ind = end_ind then\n failwith_message\n \"invalid format %S: unclosed sub-format, \\\n expected \\\"%%%c\\\" at character number %d\" str c end_ind;\n match str.[str_ind] with\n | '%' ->\n if str_ind + 1 = end_ind then unexpected_end_of_format end_ind;\n if str.[str_ind + 1] = c then (* End of format found *) str_ind else\n begin match str.[str_ind + 1] with\n | '_' ->\n (* Search for \"%_(\" or \"%_{\". *)\n if str_ind + 2 = end_ind then unexpected_end_of_format end_ind;\n begin match str.[str_ind + 2] with\n | '{' ->\n let sub_end = search_subformat_end (str_ind + 3) end_ind '}' in\n search_subformat_end (sub_end + 2) end_ind c\n | '(' ->\n let sub_end = search_subformat_end (str_ind + 3) end_ind ')' in\n search_subformat_end (sub_end + 2) end_ind c\n | _ -> search_subformat_end (str_ind + 3) end_ind c\n end\n | '{' ->\n (* %{...%} sub-format found. *)\n let sub_end = search_subformat_end (str_ind + 2) end_ind '}' in\n search_subformat_end (sub_end + 2) end_ind c\n | '(' ->\n (* %(...%) sub-format found. *)\n let sub_end = search_subformat_end (str_ind + 2) end_ind ')' in\n search_subformat_end (sub_end + 2) end_ind c\n | '}' ->\n (* Error: %(...%}. *)\n expected_character (str_ind + 1) \"character ')'\" '}';\n | ')' ->\n (* Error: %{...%). *)\n expected_character (str_ind + 1) \"character '}'\" ')';\n | _ ->\n search_subformat_end (str_ind + 2) end_ind c\n end\n | _ -> search_subformat_end (str_ind + 1) end_ind c\n\n (* Check if symb is a valid int conversion after \"%l\", \"%n\" or \"%L\" *)\n and is_int_base symb = match symb with\n | 'd' | 'i' | 'x' | 'X' | 'o' | 'u' -> true\n | _ -> false\n\n (* Convert a char (l, n or L) to its associated counter. *)\n and counter_of_char symb = match symb with\n | 'l' -> Line_counter | 'n' -> Char_counter\n | 'L' -> Token_counter | _ -> assert false\n\n (* Convert (plus, symb) to its associated int_conv. *)\n and compute_int_conv pct_ind str_ind plus sharp space symb =\n match plus, sharp, space, symb with\n | false, false, false, 'd' -> Int_d | false, false, false, 'i' -> Int_i\n | false, false, true, 'd' -> Int_sd | false, false, true, 'i' -> Int_si\n | true, false, false, 'd' -> Int_pd | true, false, false, 'i' -> Int_pi\n | false, false, false, 'x' -> Int_x | false, false, false, 'X' -> Int_X\n | false, true, false, 'x' -> Int_Cx | false, true, false, 'X' -> Int_CX\n | false, false, false, 'o' -> Int_o\n | false, true, false, 'o' -> Int_Co\n | false, false, false, 'u' -> Int_u\n | _, true, _, 'x' when legacy_behavior -> Int_Cx\n | _, true, _, 'X' when legacy_behavior -> Int_CX\n | _, true, _, 'o' when legacy_behavior -> Int_Co\n | _, true, _, ('d' | 'i' | 'u') ->\n if legacy_behavior then (* ignore *)\n compute_int_conv pct_ind str_ind plus false space symb\n else incompatible_flag pct_ind str_ind symb \"'#'\"\n | true, _, true, _ ->\n if legacy_behavior then\n (* plus and space: legacy implementation prefers plus *)\n compute_int_conv pct_ind str_ind plus sharp false symb\n else incompatible_flag pct_ind str_ind ' ' \"'+'\"\n | false, _, true, _ ->\n if legacy_behavior then (* ignore *)\n compute_int_conv pct_ind str_ind plus sharp false symb\n else incompatible_flag pct_ind str_ind symb \"' '\"\n | true, _, false, _ ->\n if legacy_behavior then (* ignore *)\n compute_int_conv pct_ind str_ind false sharp space symb\n else incompatible_flag pct_ind str_ind symb \"'+'\"\n | false, _, false, _ -> assert false\n\n (* Convert (plus, symb) to its associated float_conv. *)\n and compute_float_conv pct_ind str_ind plus space symb =\n match plus, space, symb with\n | false, false, 'f' -> Float_f | false, false, 'e' -> Float_e\n | false, true, 'f' -> Float_sf | false, true, 'e' -> Float_se\n | true, false, 'f' -> Float_pf | true, false, 'e' -> Float_pe\n | false, false, 'E' -> Float_E | false, false, 'g' -> Float_g\n | false, true, 'E' -> Float_sE | false, true, 'g' -> Float_sg\n | true, false, 'E' -> Float_pE | true, false, 'g' -> Float_pg\n | false, false, 'G' -> Float_G\n | false, true, 'G' -> Float_sG\n | true, false, 'G' -> Float_pG\n | false, false, 'F' -> Float_F\n | true, true, _ ->\n if legacy_behavior then\n (* plus and space: legacy implementation prefers plus *)\n compute_float_conv pct_ind str_ind plus false symb\n else incompatible_flag pct_ind str_ind ' ' \"'+'\"\n | false, true, _ ->\n if legacy_behavior then (* ignore *)\n compute_float_conv pct_ind str_ind plus false symb\n else incompatible_flag pct_ind str_ind symb \"' '\"\n | true, false, _ ->\n if legacy_behavior then (* ignore *)\n compute_float_conv pct_ind str_ind false space symb\n else incompatible_flag pct_ind str_ind symb \"'+'\"\n | false, false, _ -> assert false\n\n (* Raise a Failure with a friendly error message about incompatible options.*)\n and incompatible_flag : type a . int -> int -> char -> string -> a =\n fun pct_ind str_ind symb option ->\n let subfmt = String.sub str pct_ind (str_ind - pct_ind) in\n failwith_message\n \"invalid format %S: at character number %d, \\\n %s is incompatible with '%c' in sub-format %S\"\n str pct_ind option symb subfmt;\n\n in parse 0 (String.length str)\n\n(******************************************************************************)\n (* Guarded string to format conversions *)\n\n(* Convert a string to a format according to an fmtty. *)\n(* Raise a Failure with an error message in case of type mismatch. *)\nlet format_of_string_fmtty str fmtty =\n let Fmt_EBB fmt = fmt_ebb_of_string str in\n try Format (type_format fmt fmtty, str)\n with Type_mismatch ->\n failwith_message\n \"bad input: format type mismatch between %S and %S\"\n str (string_of_fmtty fmtty)\n\n(* Convert a string to a format compatible with an other format. *)\n(* Raise a Failure with an error message in case of type mismatch. *)\nlet format_of_string_format str (Format (fmt', str')) =\n let Fmt_EBB fmt = fmt_ebb_of_string str in\n try Format (type_format fmt (fmtty_of_fmt fmt'), str)\n with Type_mismatch ->\n failwith_message\n \"bad input: format type mismatch between %S and %S\" str str'\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy and Pierre Weis, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\nopen CamlinternalFormatBasics\nopen CamlinternalFormat\n\nlet kfprintf k o (Format (fmt, _)) =\n make_printf (fun o acc -> output_acc o acc; k o) o End_of_acc fmt\nlet kbprintf k b (Format (fmt, _)) =\n make_printf (fun b acc -> bufput_acc b acc; k b) b End_of_acc fmt\nlet ikfprintf k oc (Format (fmt, _)) =\n make_printf (fun oc _ -> k oc) oc End_of_acc fmt\n\nlet fprintf oc fmt = kfprintf ignore oc fmt\nlet bprintf b fmt = kbprintf ignore b fmt\nlet ifprintf oc fmt = ikfprintf ignore oc fmt\nlet printf fmt = fprintf stdout fmt\nlet eprintf fmt = fprintf stderr fmt\n\nlet ksprintf k (Format (fmt, _)) =\n let k' () acc =\n let buf = Buffer.create 64 in\n strput_acc buf acc;\n k (Buffer.contents buf) in\n make_printf k' () End_of_acc fmt\n\nlet sprintf fmt = ksprintf (fun s -> s) fmt\n\nlet kprintf = ksprintf\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\nopen Printf;;\n\nlet printers = ref []\n\nlet locfmt = format_of_string \"File \\\"%s\\\", line %d, characters %d-%d: %s\";;\n\nlet field x i =\n let f = Obj.field x i in\n if not (Obj.is_block f) then\n sprintf \"%d\" (Obj.magic f : int) (* can also be a char *)\n else if Obj.tag f = Obj.string_tag then\n sprintf \"%S\" (Obj.magic f : string)\n else if Obj.tag f = Obj.double_tag then\n string_of_float (Obj.magic f : float)\n else\n \"_\"\n;;\nlet rec other_fields x i =\n if i >= Obj.size x then \"\"\n else sprintf \", %s%s\" (field x i) (other_fields x (i+1))\n;;\nlet fields x =\n match Obj.size x with\n | 0 -> \"\"\n | 1 -> \"\"\n | 2 -> sprintf \"(%s)\" (field x 1)\n | n -> sprintf \"(%s%s)\" (field x 1) (other_fields x 2)\n;;\n\nlet to_string x =\n let rec conv = function\n | hd :: tl ->\n (match try hd x with _ -> None with\n | Some s -> s\n | None -> conv tl)\n | [] ->\n match x with\n | Out_of_memory -> \"Out of memory\"\n | Stack_overflow -> \"Stack overflow\"\n | Match_failure(file, line, char) ->\n sprintf locfmt file line char (char+5) \"Pattern matching failed\"\n | Assert_failure(file, line, char) ->\n sprintf locfmt file line char (char+6) \"Assertion failed\"\n | Undefined_recursive_module(file, line, char) ->\n sprintf locfmt file line char (char+6) \"Undefined recursive module\"\n | _ ->\n let x = Obj.repr x in\n if Obj.tag x <> 0 then\n (Obj.magic (Obj.field x 0) : string)\n else\n let constructor =\n (Obj.magic (Obj.field (Obj.field x 0) 0) : string) in\n constructor ^ (fields x) in\n conv !printers\n\nlet print fct arg =\n try\n fct arg\n with x ->\n eprintf \"Uncaught exception: %s\\n\" (to_string x);\n flush stderr;\n raise x\n\nlet catch fct arg =\n try\n fct arg\n with x ->\n flush stdout;\n eprintf \"Uncaught exception: %s\\n\" (to_string x);\n exit 2\n\ntype raw_backtrace_slot\ntype raw_backtrace = raw_backtrace_slot array\n\nexternal get_raw_backtrace:\n unit -> raw_backtrace = \"caml_get_exception_raw_backtrace\"\n\ntype backtrace_slot =\n | Known_location of bool (* is_raise *)\n * string (* filename *)\n * int (* line number *)\n * int (* start char *)\n * int (* end char *)\n | Unknown_location of bool (*is_raise*)\n\n(* to avoid warning *)\nlet _ = [Known_location (false, \"\", 0, 0, 0); Unknown_location false]\n\nexternal convert_raw_backtrace_slot:\n raw_backtrace_slot -> backtrace_slot = \"caml_convert_raw_backtrace_slot\"\n\nlet convert_raw_backtrace rbckt =\n try Some (Array.map convert_raw_backtrace_slot rbckt)\n with Failure _ -> None\n\nlet format_backtrace_slot pos slot =\n let info is_raise =\n if is_raise then\n if pos = 0 then \"Raised at\" else \"Re-raised at\"\n else\n if pos = 0 then \"Raised by primitive operation at\" else \"Called from\"\n in\n match slot with\n | Unknown_location true -> (* compiler-inserted re-raise, skipped *) None\n | Unknown_location false ->\n Some (sprintf \"%s unknown location\" (info false))\n | Known_location(is_raise, filename, lineno, startchar, endchar) ->\n Some (sprintf \"%s file \\\"%s\\\", line %d, characters %d-%d\"\n (info is_raise) filename lineno startchar endchar)\n\nlet print_exception_backtrace outchan backtrace =\n match backtrace with\n | None ->\n fprintf outchan\n \"(Program not linked with -g, cannot print stack backtrace)\\n\"\n | Some a ->\n for i = 0 to Array.length a - 1 do\n match format_backtrace_slot i a.(i) with\n | None -> ()\n | Some str -> fprintf outchan \"%s\\n\" str\n done\n\nlet print_raw_backtrace outchan raw_backtrace =\n print_exception_backtrace outchan (convert_raw_backtrace raw_backtrace)\n\n(* confusingly named: prints the global current backtrace *)\nlet print_backtrace outchan =\n print_raw_backtrace outchan (get_raw_backtrace ())\n\nlet backtrace_to_string backtrace =\n match backtrace with\n | None ->\n \"(Program not linked with -g, cannot print stack backtrace)\\n\"\n | Some a ->\n let b = Buffer.create 1024 in\n for i = 0 to Array.length a - 1 do\n match format_backtrace_slot i a.(i) with\n | None -> ()\n | Some str -> bprintf b \"%s\\n\" str\n done;\n Buffer.contents b\n\nlet raw_backtrace_to_string raw_backtrace =\n backtrace_to_string (convert_raw_backtrace raw_backtrace)\n\nlet backtrace_slot_is_raise = function\n | Known_location(is_raise, _, _, _, _) -> is_raise\n | Unknown_location(is_raise) -> is_raise\n\ntype location = {\n filename : string;\n line_number : int;\n start_char : int;\n end_char : int;\n}\n\nlet backtrace_slot_location = function\n | Unknown_location _ -> None\n | Known_location(_is_raise, filename, line_number,\n start_char, end_char) ->\n Some {\n filename;\n line_number;\n start_char;\n end_char;\n }\n\nlet backtrace_slots raw_backtrace =\n (* The documentation of this function guarantees that Some is\n returned only if a part of the trace is usable. This gives us\n a bit more work than just convert_raw_backtrace, but it makes the\n API more user-friendly -- otherwise most users would have to\n reimplement the \"Program not linked with -g, sorry\" logic\n themselves. *)\n match convert_raw_backtrace raw_backtrace with\n | None -> None\n | Some backtrace ->\n let usable_slot = function\n | Unknown_location _ -> false\n | Known_location _ -> true in\n let rec exists_usable = function\n | (-1) -> false\n | i -> usable_slot backtrace.(i) || exists_usable (i - 1) in\n if exists_usable (Array.length backtrace - 1)\n then Some backtrace\n else None\n\nmodule Slot = struct\n type t = backtrace_slot\n let format = format_backtrace_slot\n let is_raise = backtrace_slot_is_raise\n let location = backtrace_slot_location\nend\n\nlet raw_backtrace_length bckt = Array.length bckt\nlet get_raw_backtrace_slot bckt i = Array.get bckt i\n\n(* confusingly named:\n returns the *string* corresponding to the global current backtrace *)\nlet get_backtrace () =\n backtrace_to_string (convert_raw_backtrace (get_raw_backtrace ()))\n\nexternal record_backtrace: bool -> unit = \"caml_record_backtrace\"\nexternal backtrace_status: unit -> bool = \"caml_backtrace_status\"\n\nlet register_printer fn =\n printers := fn :: !printers\n\nexternal get_callstack: int -> raw_backtrace = \"caml_get_current_callstack\"\n\nlet exn_slot x =\n let x = Obj.repr x in\n if Obj.tag x = 0 then Obj.field x 0 else x\n\nlet exn_slot_id x =\n let slot = exn_slot x in\n (Obj.obj (Obj.field slot 1) : int)\n\nlet exn_slot_name x =\n let slot = exn_slot x in\n (Obj.obj (Obj.field slot 0) : string)\n\n\nlet uncaught_exception_handler = ref None\n\nlet set_uncaught_exception_handler fn = uncaught_exception_handler := Some fn\n\nlet empty_backtrace : raw_backtrace = Obj.obj (Obj.new_block Obj.abstract_tag 0)\n\nlet try_get_raw_backtrace () =\n try\n get_raw_backtrace ()\n with _ (* Out_of_memory? *) ->\n empty_backtrace\n\nlet handle_uncaught_exception' exn debugger_in_use =\n try\n (* Get the backtrace now, in case one of the [at_exit] function\n destroys it. *)\n let raw_backtrace =\n if debugger_in_use (* Same test as in [byterun/printexc.c] *) then\n empty_backtrace\n else\n try_get_raw_backtrace ()\n in\n (try Pervasives.do_at_exit () with _ -> ());\n match !uncaught_exception_handler with\n | None ->\n eprintf \"Fatal error: exception %s\\n\" (to_string exn);\n print_raw_backtrace stderr raw_backtrace;\n flush stderr\n | Some handler ->\n try\n handler exn raw_backtrace\n with exn' ->\n let raw_backtrace' = try_get_raw_backtrace () in\n eprintf \"Fatal error: exception %s\\n\" (to_string exn);\n print_raw_backtrace stderr raw_backtrace;\n eprintf \"Fatal error in uncaught exception handler: exception %s\\n\"\n (to_string exn');\n print_raw_backtrace stderr raw_backtrace';\n flush stderr\n with\n | Out_of_memory ->\n prerr_endline\n \"Fatal error: out of memory in uncaught exception handler\"\n\n(* This function is called by [caml_fatal_uncaught_exception] in\n [byterun/printexc.c] which expects no exception is raised. *)\nlet handle_uncaught_exception exn debugger_in_use =\n try\n handle_uncaught_exception' exn debugger_in_use\n with _ ->\n (* There is not much we can do at this point *)\n ()\n\nexternal register_named_value : string -> 'a -> unit\n = \"caml_register_named_value\"\n\nlet () =\n register_named_value \"Printexc.handle_uncaught_exception\"\n handle_uncaught_exception\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* Pseudo-random number generator\n This is a lagged-Fibonacci F(55, 24, +) with a modified addition\n function to enhance the mixing of bits.\n If we use normal addition, the low-order bit fails tests 1 and 7\n of the Diehard test suite, and bits 1 and 2 also fail test 7.\n If we use multiplication as suggested by Marsaglia, it doesn't fare\n much better.\n By mixing the bits of one of the numbers before addition (XOR the\n 5 high-order bits into the low-order bits), we get a generator that\n passes all the Diehard tests.\n*)\n\nexternal random_seed: unit -> int array = \"caml_sys_random_seed\";;\n\nmodule State = struct\n\n type t = { st : int array; mutable idx : int };;\n\n let new_state () = { st = Array.make 55 0; idx = 0 };;\n let assign st1 st2 =\n Array.blit st2.st 0 st1.st 0 55;\n st1.idx <- st2.idx;\n ;;\n\n let full_init s seed =\n let combine accu x = Digest.string (accu ^ string_of_int x) in\n let extract d =\n Char.code d.[0] + (Char.code d.[1] lsl 8) + (Char.code d.[2] lsl 16)\n + (Char.code d.[3] lsl 24)\n in\n let seed = if Array.length seed = 0 then [| 0 |] else seed in\n let l = Array.length seed in\n for i = 0 to 54 do\n s.st.(i) <- i;\n done;\n let accu = ref \"x\" in\n for i = 0 to 54 + max 55 l do\n let j = i mod 55 in\n let k = i mod l in\n accu := combine !accu seed.(k);\n s.st.(j) <- (s.st.(j) lxor extract !accu) land 0x3FFFFFFF; (* PR#5575 *)\n done;\n s.idx <- 0;\n ;;\n\n let make seed =\n let result = new_state () in\n full_init result seed;\n result\n ;;\n\n let make_self_init () = make (random_seed ());;\n\n let copy s =\n let result = new_state () in\n assign result s;\n result\n ;;\n\n (* Returns 30 random bits as an integer 0 <= x < 1073741824 *)\n let bits s =\n s.idx <- (s.idx + 1) mod 55;\n let curval = s.st.(s.idx) in\n let newval = s.st.((s.idx + 24) mod 55)\n + (curval lxor ((curval lsr 25) land 0x1F)) in\n let newval30 = newval land 0x3FFFFFFF in (* PR#5575 *)\n s.st.(s.idx) <- newval30;\n newval30\n ;;\n\n let rec intaux s n =\n let r = bits s in\n let v = r mod n in\n if r - v > 0x3FFFFFFF - n + 1 then intaux s n else v\n ;;\n let int s bound =\n if bound > 0x3FFFFFFF || bound <= 0\n then invalid_arg \"Random.int\"\n else intaux s bound\n ;;\n\n let rec int32aux s n =\n let b1 = Int32.of_int (bits s) in\n let b2 = Int32.shift_left (Int32.of_int (bits s land 1)) 30 in\n let r = Int32.logor b1 b2 in\n let v = Int32.rem r n in\n if Int32.sub r v > Int32.add (Int32.sub Int32.max_int n) 1l\n then int32aux s n\n else v\n ;;\n let int32 s bound =\n if bound <= 0l\n then invalid_arg \"Random.int32\"\n else int32aux s bound\n ;;\n\n let rec int64aux s n =\n let b1 = Int64.of_int (bits s) in\n let b2 = Int64.shift_left (Int64.of_int (bits s)) 30 in\n let b3 = Int64.shift_left (Int64.of_int (bits s land 7)) 60 in\n let r = Int64.logor b1 (Int64.logor b2 b3) in\n let v = Int64.rem r n in\n if Int64.sub r v > Int64.add (Int64.sub Int64.max_int n) 1L\n then int64aux s n\n else v\n ;;\n let int64 s bound =\n if bound <= 0L\n then invalid_arg \"Random.int64\"\n else int64aux s bound\n ;;\n\n let nativeint =\n if Nativeint.size = 32\n then fun s bound -> Nativeint.of_int32 (int32 s (Nativeint.to_int32 bound))\n else fun s bound -> Int64.to_nativeint (int64 s (Int64.of_nativeint bound))\n ;;\n\n (* Returns a float 0 <= x <= 1 with at most 60 bits of precision. *)\n let rawfloat s =\n let scale = 1073741824.0 (* 2^30 *)\n and r1 = Pervasives.float (bits s)\n and r2 = Pervasives.float (bits s)\n in (r1 /. scale +. r2) /. scale\n ;;\n\n let float s bound = rawfloat s *. bound;;\n\n let bool s = (bits s land 1 = 0);;\n\nend;;\n\n(* This is the state you get with [init 27182818] and then applying\n the \"land 0x3FFFFFFF\" filter to them. See #5575, #5793, #5977. *)\nlet default = {\n State.st = [|\n 0x3ae2522b; 0x1d8d4634; 0x15b4fad0; 0x18b14ace; 0x12f8a3c4; 0x3b086c47;\n 0x16d467d6; 0x101d91c7; 0x321df177; 0x0176c193; 0x1ff72bf1; 0x1e889109;\n 0x0b464b18; 0x2b86b97c; 0x0891da48; 0x03137463; 0x085ac5a1; 0x15d61f2f;\n 0x3bced359; 0x29c1c132; 0x3a86766e; 0x366d8c86; 0x1f5b6222; 0x3ce1b59f;\n 0x2ebf78e1; 0x27cd1b86; 0x258f3dc3; 0x389a8194; 0x02e4c44c; 0x18c43f7d;\n 0x0f6e534f; 0x1e7df359; 0x055d0b7e; 0x10e84e7e; 0x126198e4; 0x0e7722cb;\n 0x1cbede28; 0x3391b964; 0x3d40e92a; 0x0c59933d; 0x0b8cd0b7; 0x24efff1c;\n 0x2803fdaa; 0x08ebc72e; 0x0f522e32; 0x05398edc; 0x2144a04c; 0x0aef3cbd;\n 0x01ad4719; 0x35b93cd6; 0x2a559d4f; 0x1e6fd768; 0x26e27f36; 0x186f18c3;\n 0x2fbf967a;\n |];\n State.idx = 0;\n};;\n\nlet bits () = State.bits default;;\nlet int bound = State.int default bound;;\nlet int32 bound = State.int32 default bound;;\nlet nativeint bound = State.nativeint default bound;;\nlet int64 bound = State.int64 default bound;;\nlet float scale = State.float default scale;;\nlet bool () = State.bool default;;\n\nlet full_init seed = State.full_init default seed;;\nlet init seed = State.full_init default [| seed |];;\nlet self_init () = full_init (random_seed());;\n\n(* Manipulating the current state. *)\n\nlet get_state () = State.copy default;;\nlet set_state s = State.assign default s;;\n\n(********************\n\n(* Test functions. Not included in the library.\n The [chisquare] function should be called with n > 10r.\n It returns a triple (low, actual, high).\n If low <= actual <= high, the [g] function passed the test,\n otherwise it failed.\n\n Some results:\n\ninit 27182818; chisquare int 100000 1000;;\ninit 27182818; chisquare int 100000 100;;\ninit 27182818; chisquare int 100000 5000;;\ninit 27182818; chisquare int 1000000 1000;;\ninit 27182818; chisquare int 100000 1024;;\ninit 299792643; chisquare int 100000 1024;;\ninit 14142136; chisquare int 100000 1024;;\ninit 27182818; init_diff 1024; chisquare diff 100000 1024;;\ninit 27182818; init_diff 100; chisquare diff 100000 100;;\ninit 27182818; init_diff2 1024; chisquare diff2 100000 1024;;\ninit 27182818; init_diff2 100; chisquare diff2 100000 100;;\ninit 14142136; init_diff2 100; chisquare diff2 100000 100;;\ninit 299792643; init_diff2 100; chisquare diff2 100000 100;;\n- : float * float * float = (936.754446796632465, 997.5, 1063.24555320336754)\n# - : float * float * float = (80., 89.7400000000052387, 120.)\n# - : float * float * float = (4858.57864376269, 5045.5, 5141.42135623731)\n# - : float * float * float =\n(936.754446796632465, 944.805999999982305, 1063.24555320336754)\n# - : float * float * float = (960., 1019.19744000000355, 1088.)\n# - : float * float * float = (960., 1059.31776000000536, 1088.)\n# - : float * float * float = (960., 1039.98463999999512, 1088.)\n# - : float * float * float = (960., 1054.38207999999577, 1088.)\n# - : float * float * float = (80., 90.096000000005, 120.)\n# - : float * float * float = (960., 1076.78720000000612, 1088.)\n# - : float * float * float = (80., 85.1760000000067521, 120.)\n# - : float * float * float = (80., 85.2160000000003492, 120.)\n# - : float * float * float = (80., 80.6220000000030268, 120.)\n\n*)\n\n(* Return the sum of the squares of v[i0,i1[ *)\nlet rec sumsq v i0 i1 =\n if i0 >= i1 then 0.0\n else if i1 = i0 + 1 then Pervasives.float v.(i0) *. Pervasives.float v.(i0)\n else sumsq v i0 ((i0+i1)/2) +. sumsq v ((i0+i1)/2) i1\n;;\n\nlet chisquare g n r =\n if n <= 10 * r then invalid_arg \"chisquare\";\n let f = Array.make r 0 in\n for i = 1 to n do\n let t = g r in\n f.(t) <- f.(t) + 1\n done;\n let t = sumsq f 0 r\n and r = Pervasives.float r\n and n = Pervasives.float n in\n let sr = 2.0 *. sqrt r in\n (r -. sr, (r *. t /. n) -. n, r +. sr)\n;;\n\n(* This is to test for linear dependencies between successive random numbers.\n*)\nlet st = ref 0;;\nlet init_diff r = st := int r;;\nlet diff r =\n let x1 = !st\n and x2 = int r\n in\n st := x2;\n if x1 >= x2 then\n x1 - x2\n else\n r + x1 - x2\n;;\n\nlet st1 = ref 0\nand st2 = ref 0\n;;\n\n(* This is to test for quadratic dependencies between successive random\n numbers.\n*)\nlet init_diff2 r = st1 := int r; st2 := int r;;\nlet diff2 r =\n let x1 = !st1\n and x2 = !st2\n and x3 = int r\n in\n st1 := x2;\n st2 := x3;\n (x3 - x2 - x2 + x1 + 2*r) mod r\n;;\n\n********************)\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* Message digest (MD5) *)\n\ntype t = string\n\nlet compare = String.compare\n\nexternal unsafe_string: string -> int -> int -> t = \"caml_md5_string\"\nexternal channel: in_channel -> int -> t = \"caml_md5_chan\"\n\nlet string str =\n unsafe_string str 0 (String.length str)\n\nlet bytes b = string (Bytes.unsafe_to_string b)\n\nlet substring str ofs len =\n if ofs < 0 || len < 0 || ofs > String.length str - len\n then invalid_arg \"Digest.substring\"\n else unsafe_string str ofs len\n\nlet subbytes b ofs len = substring (Bytes.unsafe_to_string b) ofs len\n\nlet file filename =\n let ic = open_in_bin filename in\n match channel ic (-1) with\n | d -> close_in ic; d\n | exception e -> close_in ic; raise e\n\nlet output chan digest =\n output_string chan digest\n\nlet input chan = really_input_string chan 16\n\nlet char_hex n =\n Char.unsafe_chr (n + if n < 10 then Char.code '0' else (Char.code 'a' - 10))\n\nlet to_hex d =\n let result = Bytes.create 32 in\n for i = 0 to 15 do\n let x = Char.code d.[i] in\n Bytes.unsafe_set result (i*2) (char_hex (x lsr 4));\n Bytes.unsafe_set result (i*2+1) (char_hex (x land 0x0f));\n done;\n Bytes.unsafe_to_string result\n\nlet from_hex s =\n if String.length s <> 32 then raise (Invalid_argument \"Digest.from_hex\");\n let digit c =\n match c with\n | '0'..'9' -> Char.code c - Char.code '0'\n | 'A'..'F' -> Char.code c - Char.code 'A' + 10\n | 'a'..'f' -> Char.code c - Char.code 'a' + 10\n | _ -> raise (Invalid_argument \"Digest.from_hex\")\n in\n let byte i = digit s.[i] lsl 4 + digit s.[i+1] in\n let result = Bytes.create 16 in\n for i = 0 to 15 do\n Bytes.set result i (Char.chr (byte (2 * i)));\n done;\n Bytes.unsafe_to_string result\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* Array operations *)\n\nexternal length : 'a array -> int = \"%array_length\"\nexternal get: 'a array -> int -> 'a = \"%array_safe_get\"\nexternal set: 'a array -> int -> 'a -> unit = \"%array_safe_set\"\nexternal unsafe_get: 'a array -> int -> 'a = \"%array_unsafe_get\"\nexternal unsafe_set: 'a array -> int -> 'a -> unit = \"%array_unsafe_set\"\nexternal make: int -> 'a -> 'a array = \"caml_make_vect\"\nexternal create: int -> 'a -> 'a array = \"caml_make_vect\"\nexternal unsafe_sub : 'a array -> int -> int -> 'a array = \"caml_array_sub\"\nexternal append_prim : 'a array -> 'a array -> 'a array = \"caml_array_append\"\nexternal concat : 'a array list -> 'a array = \"caml_array_concat\"\nexternal unsafe_blit :\n 'a array -> int -> 'a array -> int -> int -> unit = \"caml_array_blit\"\nexternal make_float: int -> float array = \"caml_make_float_vect\"\n\nlet init l f =\n if l = 0 then [||] else\n if l < 0 then invalid_arg \"Array.init\"\n (* See #6575. We could also check for maximum array size, but this depends\n on whether we create a float array or a regular one... *)\n else\n let res = create l (f 0) in\n for i = 1 to pred l do\n unsafe_set res i (f i)\n done;\n res\n\nlet make_matrix sx sy init =\n let res = create sx [||] in\n for x = 0 to pred sx do\n unsafe_set res x (create sy init)\n done;\n res\n\nlet create_matrix = make_matrix\n\nlet copy a =\n let l = length a in if l = 0 then [||] else unsafe_sub a 0 l\n\nlet append a1 a2 =\n let l1 = length a1 in\n if l1 = 0 then copy a2\n else if length a2 = 0 then unsafe_sub a1 0 l1\n else append_prim a1 a2\n\nlet sub a ofs len =\n if len < 0 || ofs > length a - len\n then invalid_arg \"Array.sub\"\n else unsafe_sub a ofs len\n\nlet fill a ofs len v =\n if ofs < 0 || len < 0 || ofs > length a - len\n then invalid_arg \"Array.fill\"\n else for i = ofs to ofs + len - 1 do unsafe_set a i v done\n\nlet blit a1 ofs1 a2 ofs2 len =\n if len < 0 || ofs1 < 0 || ofs1 > length a1 - len\n || ofs2 < 0 || ofs2 > length a2 - len\n then invalid_arg \"Array.blit\"\n else unsafe_blit a1 ofs1 a2 ofs2 len\n\nlet iter f a =\n for i = 0 to length a - 1 do f(unsafe_get a i) done\n\nlet map f a =\n let l = length a in\n if l = 0 then [||] else begin\n let r = create l (f(unsafe_get a 0)) in\n for i = 1 to l - 1 do\n unsafe_set r i (f(unsafe_get a i))\n done;\n r\n end\n\nlet iteri f a =\n for i = 0 to length a - 1 do f i (unsafe_get a i) done\n\nlet mapi f a =\n let l = length a in\n if l = 0 then [||] else begin\n let r = create l (f 0 (unsafe_get a 0)) in\n for i = 1 to l - 1 do\n unsafe_set r i (f i (unsafe_get a i))\n done;\n r\n end\n\nlet to_list a =\n let rec tolist i res =\n if i < 0 then res else tolist (i - 1) (unsafe_get a i :: res) in\n tolist (length a - 1) []\n\n(* Cannot use List.length here because the List module depends on Array. *)\nlet rec list_length accu = function\n | [] -> accu\n | h::t -> list_length (succ accu) t\n;;\n\nlet of_list = function\n [] -> [||]\n | hd::tl as l ->\n let a = create (list_length 0 l) hd in\n let rec fill i = function\n [] -> a\n | hd::tl -> unsafe_set a i hd; fill (i+1) tl in\n fill 1 tl\n\nlet fold_left f x a =\n let r = ref x in\n for i = 0 to length a - 1 do\n r := f !r (unsafe_get a i)\n done;\n !r\n\nlet fold_right f a x =\n let r = ref x in\n for i = length a - 1 downto 0 do\n r := f (unsafe_get a i) !r\n done;\n !r\n\nexception Bottom of int;;\nlet sort cmp a =\n let maxson l i =\n let i31 = i+i+i+1 in\n let x = ref i31 in\n if i31+2 < l then begin\n if cmp (get a i31) (get a (i31+1)) < 0 then x := i31+1;\n if cmp (get a !x) (get a (i31+2)) < 0 then x := i31+2;\n !x\n end else\n if i31+1 < l && cmp (get a i31) (get a (i31+1)) < 0\n then i31+1\n else if i31 < l then i31 else raise (Bottom i)\n in\n let rec trickledown l i e =\n let j = maxson l i in\n if cmp (get a j) e > 0 then begin\n set a i (get a j);\n trickledown l j e;\n end else begin\n set a i e;\n end;\n in\n let trickle l i e = try trickledown l i e with Bottom i -> set a i e in\n let rec bubbledown l i =\n let j = maxson l i in\n set a i (get a j);\n bubbledown l j\n in\n let bubble l i = try bubbledown l i with Bottom i -> i in\n let rec trickleup i e =\n let father = (i - 1) / 3 in\n assert (i <> father);\n if cmp (get a father) e < 0 then begin\n set a i (get a father);\n if father > 0 then trickleup father e else set a 0 e;\n end else begin\n set a i e;\n end;\n in\n let l = length a in\n for i = (l + 1) / 3 - 1 downto 0 do trickle l i (get a i); done;\n for i = l - 1 downto 2 do\n let e = (get a i) in\n set a i (get a 0);\n trickleup (bubble i 0) e;\n done;\n if l > 1 then (let e = (get a 1) in set a 1 (get a 0); set a 0 e);\n;;\n\nlet cutoff = 5;;\nlet stable_sort cmp a =\n let merge src1ofs src1len src2 src2ofs src2len dst dstofs =\n let src1r = src1ofs + src1len and src2r = src2ofs + src2len in\n let rec loop i1 s1 i2 s2 d =\n if cmp s1 s2 <= 0 then begin\n set dst d s1;\n let i1 = i1 + 1 in\n if i1 < src1r then\n loop i1 (get a i1) i2 s2 (d + 1)\n else\n blit src2 i2 dst (d + 1) (src2r - i2)\n end else begin\n set dst d s2;\n let i2 = i2 + 1 in\n if i2 < src2r then\n loop i1 s1 i2 (get src2 i2) (d + 1)\n else\n blit a i1 dst (d + 1) (src1r - i1)\n end\n in loop src1ofs (get a src1ofs) src2ofs (get src2 src2ofs) dstofs;\n in\n let isortto srcofs dst dstofs len =\n for i = 0 to len - 1 do\n let e = (get a (srcofs + i)) in\n let j = ref (dstofs + i - 1) in\n while (!j >= dstofs && cmp (get dst !j) e > 0) do\n set dst (!j + 1) (get dst !j);\n decr j;\n done;\n set dst (!j + 1) e;\n done;\n in\n let rec sortto srcofs dst dstofs len =\n if len <= cutoff then isortto srcofs dst dstofs len else begin\n let l1 = len / 2 in\n let l2 = len - l1 in\n sortto (srcofs + l1) dst (dstofs + l1) l2;\n sortto srcofs a (srcofs + l2) l1;\n merge (srcofs + l2) l1 dst (dstofs + l1) l2 dst dstofs;\n end;\n in\n let l = length a in\n if l <= cutoff then isortto 0 a 0 l else begin\n let l1 = l / 2 in\n let l2 = l - l1 in\n let t = make l2 (get a 0) in\n sortto l1 t 0 l2;\n sortto 0 a l2 l1;\n merge l2 l1 t 0 l2 a 0;\n end;\n;;\n\nlet fast_sort = stable_sort;;\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Weis, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* A pretty-printing facility and definition of formatters for 'parallel'\n (i.e. unrelated or independent) pretty-printing on multiple out channels. *)\n\n(**************************************************************\n\n Data structures definitions.\n\n **************************************************************)\n\ntype size;;\n\nexternal size_of_int : int -> size = \"%identity\"\n;;\nexternal int_of_size : size -> int = \"%identity\"\n;;\n\n(* Tokens are one of the following : *)\n\ntype block_type\n = CamlinternalFormatBasics.block_type\n = Pp_hbox | Pp_vbox | Pp_hvbox | Pp_hovbox | Pp_box | Pp_fits\n\ntype pp_token =\n| Pp_text of string (* normal text *)\n| Pp_break of int * int (* complete break *)\n| Pp_tbreak of int * int (* go to next tabulation *)\n| Pp_stab (* set a tabulation *)\n| Pp_begin of int * block_type (* beginning of a block *)\n| Pp_end (* end of a block *)\n| Pp_tbegin of tblock (* beginning of a tabulation block *)\n| Pp_tend (* end of a tabulation block *)\n| Pp_newline (* to force a newline inside a block *)\n| Pp_if_newline (* to do something only if this very\n line has been broken *)\n| Pp_open_tag of tag (* opening a tag name *)\n| Pp_close_tag (* closing the most recently opened tag *)\n\nand tag = string\n\nand tblock = Pp_tbox of int list ref (* Tabulation box *)\n\n(* The Queue:\n contains all formatting elements.\n elements are tuples (size, token, length), where\n size is set when the size of the block is known\n len is the declared length of the token. *)\ntype pp_queue_elem = {\n mutable elem_size : size;\n token : pp_token;\n length : int;\n}\n;;\n\n(* Scan stack:\n each element is (left_total, queue element) where left_total\n is the value of pp_left_total when the element has been enqueued. *)\ntype pp_scan_elem = Scan_elem of int * pp_queue_elem;;\n\n(* Formatting stack:\n used to break the lines while printing tokens.\n The formatting stack contains the description of\n the currently active blocks. *)\ntype pp_format_elem = Format_elem of block_type * int;;\n\n(* General purpose queues, used in the formatter. *)\ntype 'a queue_elem =\n | Nil\n | Cons of 'a queue_cell\n\nand 'a queue_cell = {\n mutable head : 'a;\n mutable tail : 'a queue_elem;\n}\n;;\n\ntype 'a queue = {\n mutable insert : 'a queue_elem;\n mutable body : 'a queue_elem;\n}\n;;\n\n(* The formatter specific tag handling functions. *)\ntype formatter_tag_functions = {\n mark_open_tag : tag -> string;\n mark_close_tag : tag -> string;\n print_open_tag : tag -> unit;\n print_close_tag : tag -> unit;\n}\n;;\n\n(* A formatter with all its machinery. *)\ntype formatter = {\n mutable pp_scan_stack : pp_scan_elem list;\n mutable pp_format_stack : pp_format_elem list;\n mutable pp_tbox_stack : tblock list;\n mutable pp_tag_stack : tag list;\n mutable pp_mark_stack : tag list;\n (* Global variables: default initialization is\n set_margin 78\n set_min_space_left 0. *)\n (* Value of right margin. *)\n mutable pp_margin : int;\n (* Minimal space left before margin, when opening a block. *)\n mutable pp_min_space_left : int;\n (* Maximum value of indentation:\n no blocks can be opened further. *)\n mutable pp_max_indent : int;\n (* Space remaining on the current line. *)\n mutable pp_space_left : int;\n (* Current value of indentation. *)\n mutable pp_current_indent : int;\n (* True when the line has been broken by the pretty-printer. *)\n mutable pp_is_new_line : bool;\n (* Total width of tokens already printed. *)\n mutable pp_left_total : int;\n (* Total width of tokens ever put in queue. *)\n mutable pp_right_total : int;\n (* Current number of opened blocks. *)\n mutable pp_curr_depth : int;\n (* Maximum number of blocks which can be simultaneously opened. *)\n mutable pp_max_boxes : int;\n (* Ellipsis string. *)\n mutable pp_ellipsis : string;\n (* Output function. *)\n mutable pp_out_string : string -> int -> int -> unit;\n (* Flushing function. *)\n mutable pp_out_flush : unit -> unit;\n (* Output of new lines. *)\n mutable pp_out_newline : unit -> unit;\n (* Output of indentation spaces. *)\n mutable pp_out_spaces : int -> unit;\n (* Are tags printed ? *)\n mutable pp_print_tags : bool;\n (* Are tags marked ? *)\n mutable pp_mark_tags : bool;\n (* Find opening and closing markers of tags. *)\n mutable pp_mark_open_tag : tag -> string;\n mutable pp_mark_close_tag : tag -> string;\n mutable pp_print_open_tag : tag -> unit;\n mutable pp_print_close_tag : tag -> unit;\n (* The pretty-printer queue. *)\n mutable pp_queue : pp_queue_elem queue;\n}\n;;\n\n(**************************************************************\n\n Auxilliaries and basic functions.\n\n **************************************************************)\n\n\n(* Queues auxilliaries. *)\nlet make_queue () = { insert = Nil; body = Nil; };;\n\nlet clear_queue q = q.insert <- Nil; q.body <- Nil;;\n\nlet add_queue x q =\n let c = Cons { head = x; tail = Nil; } in\n match q with\n | { insert = Cons cell; body = _; } ->\n q.insert <- c; cell.tail <- c\n (* Invariant: when insert is Nil body should be Nil. *)\n | { insert = Nil; body = _; } ->\n q.insert <- c; q.body <- c\n;;\n\nexception Empty_queue;;\n\nlet peek_queue = function\n | { body = Cons { head = x; tail = _; }; _ } -> x\n | { body = Nil; insert = _; } -> raise Empty_queue\n;;\n\nlet take_queue = function\n | { body = Cons { head = x; tail = tl; }; _ } as q ->\n q.body <- tl;\n if tl = Nil then q.insert <- Nil; (* Maintain the invariant. *)\n x\n | { body = Nil; insert = _; } -> raise Empty_queue\n;;\n\n(* Enter a token in the pretty-printer queue. *)\nlet pp_enqueue state ({ length = len; _} as token) =\n state.pp_right_total <- state.pp_right_total + len;\n add_queue token state.pp_queue\n;;\n\nlet pp_clear_queue state =\n state.pp_left_total <- 1; state.pp_right_total <- 1;\n clear_queue state.pp_queue\n;;\n\n(* Pp_infinity: large value for default tokens size.\n\n Pp_infinity is documented as being greater than 1e10; to avoid\n confusion about the word 'greater', we choose pp_infinity greater\n than 1e10 + 1; for correct handling of tests in the algorithm,\n pp_infinity must be even one more than 1e10 + 1; let's stand on the\n safe side by choosing 1.e10+10.\n\n Pp_infinity could probably be 1073741823 that is 2^30 - 1, that is\n the minimal upper bound for integers; now that max_int is defined,\n this limit could also be defined as max_int - 1.\n\n However, before setting pp_infinity to something around max_int, we\n must carefully double-check all the integer arithmetic operations\n that involve pp_infinity, since any overflow would wreck havoc the\n pretty-printing algorithm's invariants. Given that this arithmetic\n correctness check is difficult and error prone and given that 1e10\n + 1 is in practice large enough, there is no need to attempt to set\n pp_infinity to the theoretically maximum limit. It is not worth the\n burden ! *)\n\nlet pp_infinity = 1000000010;;\n\n(* Output functions for the formatter. *)\nlet pp_output_string state s = state.pp_out_string s 0 (String.length s)\nand pp_output_newline state = state.pp_out_newline ()\nand pp_output_spaces state n = state.pp_out_spaces n\n\n(* To format a break, indenting a new line. *)\nlet break_new_line state offset width =\n pp_output_newline state;\n state.pp_is_new_line <- true;\n let indent = state.pp_margin - width + offset in\n (* Don't indent more than pp_max_indent. *)\n let real_indent = min state.pp_max_indent indent in\n state.pp_current_indent <- real_indent;\n state.pp_space_left <- state.pp_margin - state.pp_current_indent;\n pp_output_spaces state state.pp_current_indent\n;;\n\n(* To force a line break inside a block: no offset is added. *)\nlet break_line state width = break_new_line state 0 width;;\n\n(* To format a break that fits on the current line. *)\nlet break_same_line state width =\n state.pp_space_left <- state.pp_space_left - width;\n pp_output_spaces state width\n;;\n\n(* To indent no more than pp_max_indent, if one tries to open a block\n beyond pp_max_indent, then the block is rejected on the left\n by simulating a break. *)\nlet pp_force_break_line state =\n match state.pp_format_stack with\n | Format_elem (bl_ty, width) :: _ ->\n if width > state.pp_space_left then\n (match bl_ty with\n | Pp_fits -> () | Pp_hbox -> ()\n | Pp_vbox | Pp_hvbox | Pp_hovbox | Pp_box ->\n break_line state width)\n | [] -> pp_output_newline state\n;;\n\n(* To skip a token, if the previous line has been broken. *)\nlet pp_skip_token state =\n (* When calling pp_skip_token the queue cannot be empty. *)\n match take_queue state.pp_queue with\n | { elem_size = size; length = len; token = _; } ->\n state.pp_left_total <- state.pp_left_total - len;\n state.pp_space_left <- state.pp_space_left + int_of_size size\n;;\n\n(**************************************************************\n\n The main pretty printing functions.\n\n **************************************************************)\n\n(* To format a token. *)\nlet format_pp_token state size = function\n\n | Pp_text s ->\n state.pp_space_left <- state.pp_space_left - size;\n pp_output_string state s;\n state.pp_is_new_line <- false\n\n | Pp_begin (off, ty) ->\n let insertion_point = state.pp_margin - state.pp_space_left in\n if insertion_point > state.pp_max_indent then\n (* can't open a block right there. *)\n begin pp_force_break_line state end;\n let offset = state.pp_space_left - off in\n let bl_type =\n begin match ty with\n | Pp_vbox -> Pp_vbox\n | Pp_hbox | Pp_hvbox | Pp_hovbox | Pp_box | Pp_fits ->\n if size > state.pp_space_left then ty else Pp_fits\n end in\n state.pp_format_stack <-\n Format_elem (bl_type, offset) :: state.pp_format_stack\n\n | Pp_end ->\n begin match state.pp_format_stack with\n | _ :: ls -> state.pp_format_stack <- ls\n | [] -> () (* No more block to close. *)\n end\n\n | Pp_tbegin (Pp_tbox _ as tbox) ->\n state.pp_tbox_stack <- tbox :: state.pp_tbox_stack\n\n | Pp_tend ->\n begin match state.pp_tbox_stack with\n | _ :: ls -> state.pp_tbox_stack <- ls\n | [] -> () (* No more tabulation block to close. *)\n end\n\n | Pp_stab ->\n begin match state.pp_tbox_stack with\n | Pp_tbox tabs :: _ ->\n let rec add_tab n = function\n | [] -> [n]\n | x :: l as ls -> if n < x then n :: ls else x :: add_tab n l in\n tabs := add_tab (state.pp_margin - state.pp_space_left) !tabs\n | [] -> () (* No opened tabulation block. *)\n end\n\n | Pp_tbreak (n, off) ->\n let insertion_point = state.pp_margin - state.pp_space_left in\n begin match state.pp_tbox_stack with\n | Pp_tbox tabs :: _ ->\n let rec find n = function\n | x :: l -> if x >= n then x else find n l\n | [] -> raise Not_found in\n let tab =\n match !tabs with\n | x :: _ ->\n begin\n try find insertion_point !tabs with\n | Not_found -> x\n end\n | _ -> insertion_point in\n let offset = tab - insertion_point in\n if offset >= 0\n then break_same_line state (offset + n)\n else break_new_line state (tab + off) state.pp_margin\n | [] -> () (* No opened tabulation block. *)\n end\n\n | Pp_newline ->\n begin match state.pp_format_stack with\n | Format_elem (_, width) :: _ -> break_line state width\n | [] -> pp_output_newline state (* No opened block. *)\n end\n\n | Pp_if_newline ->\n if state.pp_current_indent != state.pp_margin - state.pp_space_left\n then pp_skip_token state\n\n | Pp_break (n, off) ->\n begin match state.pp_format_stack with\n | Format_elem (ty, width) :: _ ->\n begin match ty with\n | Pp_hovbox ->\n if size > state.pp_space_left\n then break_new_line state off width\n else break_same_line state n\n | Pp_box ->\n (* Have the line just been broken here ? *)\n if state.pp_is_new_line then break_same_line state n else\n if size > state.pp_space_left\n then break_new_line state off width else\n (* break the line here leads to new indentation ? *)\n if state.pp_current_indent > state.pp_margin - width + off\n then break_new_line state off width\n else break_same_line state n\n | Pp_hvbox -> break_new_line state off width\n | Pp_fits -> break_same_line state n\n | Pp_vbox -> break_new_line state off width\n | Pp_hbox -> break_same_line state n\n end\n | [] -> () (* No opened block. *)\n end\n\n | Pp_open_tag tag_name ->\n let marker = state.pp_mark_open_tag tag_name in\n pp_output_string state marker;\n state.pp_mark_stack <- tag_name :: state.pp_mark_stack\n\n | Pp_close_tag ->\n begin match state.pp_mark_stack with\n | tag_name :: tags ->\n let marker = state.pp_mark_close_tag tag_name in\n pp_output_string state marker;\n state.pp_mark_stack <- tags\n | [] -> () (* No more tag to close. *)\n end\n;;\n\n(* Print if token size is known or printing is delayed.\n Size is known when not negative.\n Printing is delayed when the text waiting in the queue requires\n more room to format than exists on the current line.\n\n Note: [advance_loop] must be tail recursive to prevent stack overflows. *)\nlet rec advance_loop state =\n match peek_queue state.pp_queue with\n | {elem_size = size; token = tok; length = len} ->\n let size = int_of_size size in\n if not\n (size < 0 &&\n (state.pp_right_total - state.pp_left_total < state.pp_space_left))\n then begin\n ignore (take_queue state.pp_queue);\n format_pp_token state (if size < 0 then pp_infinity else size) tok;\n state.pp_left_total <- len + state.pp_left_total;\n advance_loop state\n end\n;;\n\nlet advance_left state =\n try advance_loop state with\n | Empty_queue -> ()\n;;\n\nlet enqueue_advance state tok = pp_enqueue state tok; advance_left state;;\n\n(* To enqueue a string : try to advance. *)\nlet make_queue_elem size tok len =\n { elem_size = size; token = tok; length = len; };;\n\nlet enqueue_string_as state size s =\n let len = int_of_size size in\n enqueue_advance state (make_queue_elem size (Pp_text s) len)\n;;\n\nlet enqueue_string state s =\n let len = String.length s in\n enqueue_string_as state (size_of_int len) s\n;;\n\n(* Routines for scan stack\n determine sizes of blocks. *)\n\n(* The scan_stack is never empty. *)\nlet scan_stack_bottom =\n let q_elem = make_queue_elem (size_of_int (-1)) (Pp_text \"\") 0 in\n [Scan_elem (-1, q_elem)]\n;;\n\n(* Set size of blocks on scan stack:\n if ty = true then size of break is set else size of block is set;\n in each case pp_scan_stack is popped. *)\nlet clear_scan_stack state = state.pp_scan_stack <- scan_stack_bottom;;\n\n(* Pattern matching on scan stack is exhaustive,\n since scan_stack is never empty.\n Pattern matching on token in scan stack is also exhaustive,\n since scan_push is used on breaks and opening of boxes. *)\nlet set_size state ty =\n match state.pp_scan_stack with\n | Scan_elem\n (left_tot,\n ({ elem_size = size; token = tok; length = _; } as queue_elem)) :: t ->\n let size = int_of_size size in\n (* test if scan stack contains any data that is not obsolete. *)\n if left_tot < state.pp_left_total then clear_scan_stack state else\n begin match tok with\n | Pp_break (_, _) | Pp_tbreak (_, _) ->\n if ty then\n begin\n queue_elem.elem_size <- size_of_int (state.pp_right_total + size);\n state.pp_scan_stack <- t\n end\n | Pp_begin (_, _) ->\n if not ty then\n begin\n queue_elem.elem_size <- size_of_int (state.pp_right_total + size);\n state.pp_scan_stack <- t\n end\n | Pp_text _ | Pp_stab | Pp_tbegin _ | Pp_tend | Pp_end\n | Pp_newline | Pp_if_newline\n | Pp_open_tag _ | Pp_close_tag ->\n () (* scan_push is only used for breaks and boxes. *)\n end\n | [] -> () (* scan_stack is never empty. *)\n;;\n\n(* Push a token on scan stack. If b is true set_size is called. *)\nlet scan_push state b tok =\n pp_enqueue state tok;\n if b then set_size state true;\n state.pp_scan_stack <-\n Scan_elem (state.pp_right_total, tok) :: state.pp_scan_stack\n;;\n\n(* To open a new block :\n the user may set the depth bound pp_max_boxes\n any text nested deeper is printed as the ellipsis string. *)\nlet pp_open_box_gen state indent br_ty =\n state.pp_curr_depth <- state.pp_curr_depth + 1;\n if state.pp_curr_depth < state.pp_max_boxes then\n let elem =\n make_queue_elem\n (size_of_int (- state.pp_right_total))\n (Pp_begin (indent, br_ty))\n 0 in\n scan_push state false elem else\n if state.pp_curr_depth = state.pp_max_boxes\n then enqueue_string state state.pp_ellipsis\n;;\n\n(* The box which is always opened. *)\nlet pp_open_sys_box state = pp_open_box_gen state 0 Pp_hovbox;;\n\n(* Close a block, setting sizes of its sub blocks. *)\nlet pp_close_box state () =\n if state.pp_curr_depth > 1 then\n begin\n if state.pp_curr_depth < state.pp_max_boxes then\n begin\n pp_enqueue state\n { elem_size = size_of_int 0; token = Pp_end; length = 0; };\n set_size state true; set_size state false\n end;\n state.pp_curr_depth <- state.pp_curr_depth - 1;\n end\n;;\n\n(* Open a tag, pushing it on the tag stack. *)\nlet pp_open_tag state tag_name =\n if state.pp_print_tags then\n begin\n state.pp_tag_stack <- tag_name :: state.pp_tag_stack;\n state.pp_print_open_tag tag_name\n end;\n if state.pp_mark_tags then\n pp_enqueue state {\n elem_size = size_of_int 0;\n token = Pp_open_tag tag_name;\n length = 0;\n }\n;;\n\n(* Close a tag, popping it from the tag stack. *)\nlet pp_close_tag state () =\n if state.pp_mark_tags then\n pp_enqueue state {\n elem_size = size_of_int 0;\n token = Pp_close_tag;\n length = 0;\n };\n if state.pp_print_tags then\n begin\n match state.pp_tag_stack with\n | tag_name :: tags ->\n state.pp_print_close_tag tag_name;\n state.pp_tag_stack <- tags\n | _ -> () (* No more tag to close. *)\n end\n;;\n\nlet pp_set_print_tags state b = state.pp_print_tags <- b;;\nlet pp_set_mark_tags state b = state.pp_mark_tags <- b;;\nlet pp_get_print_tags state () = state.pp_print_tags;;\nlet pp_get_mark_tags state () = state.pp_mark_tags;;\nlet pp_set_tags state b = pp_set_print_tags state b; pp_set_mark_tags state b;;\n\nlet pp_get_formatter_tag_functions state () = {\n mark_open_tag = state.pp_mark_open_tag;\n mark_close_tag = state.pp_mark_close_tag;\n print_open_tag = state.pp_print_open_tag;\n print_close_tag = state.pp_print_close_tag;\n}\n;;\n\nlet pp_set_formatter_tag_functions state {\n mark_open_tag = mot;\n mark_close_tag = mct;\n print_open_tag = pot;\n print_close_tag = pct;\n } =\n state.pp_mark_open_tag <- mot;\n state.pp_mark_close_tag <- mct;\n state.pp_print_open_tag <- pot;\n state.pp_print_close_tag <- pct\n;;\n\n(* Initialize pretty-printer. *)\nlet pp_rinit state =\n pp_clear_queue state;\n clear_scan_stack state;\n state.pp_format_stack <- [];\n state.pp_tbox_stack <- [];\n state.pp_tag_stack <- [];\n state.pp_mark_stack <- [];\n state.pp_current_indent <- 0;\n state.pp_curr_depth <- 0;\n state.pp_space_left <- state.pp_margin;\n pp_open_sys_box state;;\n\n(* Flushing pretty-printer queue. *)\nlet pp_flush_queue state b =\n while state.pp_curr_depth > 1 do\n pp_close_box state ()\n done;\n state.pp_right_total <- pp_infinity;\n advance_left state;\n if b then pp_output_newline state;\n pp_rinit state\n;;\n\n(**************************************************************\n\n Procedures to format objects, and use boxes\n\n **************************************************************)\n\n(* To format a string. *)\nlet pp_print_as_size state size s =\n if state.pp_curr_depth < state.pp_max_boxes\n then enqueue_string_as state size s\n;;\n\nlet pp_print_as state isize s =\n pp_print_as_size state (size_of_int isize) s\n;;\n\nlet pp_print_string state s =\n pp_print_as state (String.length s) s\n;;\n\n(* To format an integer. *)\nlet pp_print_int state i = pp_print_string state (string_of_int i);;\n\n(* To format a float. *)\nlet pp_print_float state f = pp_print_string state (string_of_float f);;\n\n(* To format a boolean. *)\nlet pp_print_bool state b = pp_print_string state (string_of_bool b);;\n\n(* To format a char. *)\nlet pp_print_char state c =\n pp_print_as state 1 (String.make 1 c)\n;;\n\n(* Opening boxes. *)\nlet pp_open_hbox state () = pp_open_box_gen state 0 Pp_hbox\nand pp_open_vbox state indent = pp_open_box_gen state indent Pp_vbox\n\nand pp_open_hvbox state indent = pp_open_box_gen state indent Pp_hvbox\nand pp_open_hovbox state indent = pp_open_box_gen state indent Pp_hovbox\nand pp_open_box state indent = pp_open_box_gen state indent Pp_box;;\n\n(* Print a new line after printing all queued text\n (same for print_flush but without a newline). *)\nlet pp_print_newline state () =\n pp_flush_queue state true; state.pp_out_flush ()\nand pp_print_flush state () =\n pp_flush_queue state false; state.pp_out_flush ();;\n\n(* To get a newline when one does not want to close the current block. *)\nlet pp_force_newline state () =\n if state.pp_curr_depth < state.pp_max_boxes then\n enqueue_advance state (make_queue_elem (size_of_int 0) Pp_newline 0)\n;;\n\n(* To format something if the line has just been broken. *)\nlet pp_print_if_newline state () =\n if state.pp_curr_depth < state.pp_max_boxes then\n enqueue_advance state (make_queue_elem (size_of_int 0) Pp_if_newline 0)\n;;\n\n(* Breaks: indicate where a block may be broken.\n If line is broken then offset is added to the indentation of the current\n block else (the value of) width blanks are printed.\n To do (?) : add a maximum width and offset value. *)\nlet pp_print_break state width offset =\n if state.pp_curr_depth < state.pp_max_boxes then\n let elem =\n make_queue_elem\n (size_of_int (- state.pp_right_total))\n (Pp_break (width, offset))\n width in\n scan_push state true elem\n;;\n\nlet pp_print_space state () = pp_print_break state 1 0\nand pp_print_cut state () = pp_print_break state 0 0\n;;\n\n(* Tabulation boxes. *)\nlet pp_open_tbox state () =\n state.pp_curr_depth <- state.pp_curr_depth + 1;\n if state.pp_curr_depth < state.pp_max_boxes then\n let elem =\n make_queue_elem (size_of_int 0) (Pp_tbegin (Pp_tbox (ref []))) 0 in\n enqueue_advance state elem\n;;\n\n(* Close a tabulation block. *)\nlet pp_close_tbox state () =\n if state.pp_curr_depth > 1 then\n begin\n if state.pp_curr_depth < state.pp_max_boxes then\n let elem = make_queue_elem (size_of_int 0) Pp_tend 0 in\n enqueue_advance state elem;\n state.pp_curr_depth <- state.pp_curr_depth - 1\n end\n;;\n\n(* Print a tabulation break. *)\nlet pp_print_tbreak state width offset =\n if state.pp_curr_depth < state.pp_max_boxes then\n let elem =\n make_queue_elem\n (size_of_int (- state.pp_right_total))\n (Pp_tbreak (width, offset))\n width in\n scan_push state true elem\n;;\n\nlet pp_print_tab state () = pp_print_tbreak state 0 0;;\n\nlet pp_set_tab state () =\n if state.pp_curr_depth < state.pp_max_boxes then\n let elem =\n make_queue_elem (size_of_int 0) Pp_stab 0 in\n enqueue_advance state elem\n;;\n\n\n(* Convenience functions *)\n\n(* To format a list *)\nlet rec pp_print_list ?(pp_sep = pp_print_cut) pp_v ppf = function\n | [] -> ()\n | [v] -> pp_v ppf v\n | v :: vs ->\n pp_v ppf v;\n pp_sep ppf ();\n pp_print_list ~pp_sep pp_v ppf vs\n\n(* To format free-flowing text *)\nlet pp_print_text ppf s =\n let len = String.length s in\n let left = ref 0 in\n let right = ref 0 in\n let flush () =\n pp_print_string ppf (String.sub s !left (!right - !left));\n incr right; left := !right;\n in\n while (!right <> len) do\n match s.[!right] with\n | '\\n' ->\n flush ();\n pp_force_newline ppf ()\n | ' ' ->\n flush (); pp_print_space ppf ()\n (* there is no specific support for '\\t'\n as it is unclear what a right semantics would be *)\n | _ -> incr right\n done;\n if !left <> len then flush ()\n\n\n(**************************************************************\n\n Procedures to control the pretty-printers\n\n **************************************************************)\n\n(* Fit max_boxes. *)\nlet pp_set_max_boxes state n = if n > 1 then state.pp_max_boxes <- n;;\n\n(* To know the current maximum number of boxes allowed. *)\nlet pp_get_max_boxes state () = state.pp_max_boxes;;\n\nlet pp_over_max_boxes state () = state.pp_curr_depth = state.pp_max_boxes;;\n\n(* Ellipsis. *)\nlet pp_set_ellipsis_text state s = state.pp_ellipsis <- s\nand pp_get_ellipsis_text state () = state.pp_ellipsis\n;;\n\n(* To set the margin of pretty-printer. *)\nlet pp_limit n =\n if n < pp_infinity then n else pred pp_infinity\n;;\n\nlet pp_set_min_space_left state n =\n if n >= 1 then\n let n = pp_limit n in\n state.pp_min_space_left <- n;\n state.pp_max_indent <- state.pp_margin - state.pp_min_space_left;\n pp_rinit state\n;;\n\n(* Initially, we have :\n pp_max_indent = pp_margin - pp_min_space_left, and\n pp_space_left = pp_margin. *)\nlet pp_set_max_indent state n =\n pp_set_min_space_left state (state.pp_margin - n)\n;;\nlet pp_get_max_indent state () = state.pp_max_indent;;\n\nlet pp_set_margin state n =\n if n >= 1 then\n let n = pp_limit n in\n state.pp_margin <- n;\n let new_max_indent =\n (* Try to maintain max_indent to its actual value. *)\n if state.pp_max_indent <= state.pp_margin\n then state.pp_max_indent else\n (* If possible maintain pp_min_space_left to its actual value,\n if this leads to a too small max_indent, take half of the\n new margin, if it is greater than 1. *)\n max (max (state.pp_margin - state.pp_min_space_left)\n (state.pp_margin / 2)) 1 in\n (* Rebuild invariants. *)\n pp_set_max_indent state new_max_indent\n;;\n\nlet pp_get_margin state () = state.pp_margin;;\n\ntype formatter_out_functions = {\n out_string : string -> int -> int -> unit;\n out_flush : unit -> unit;\n out_newline : unit -> unit;\n out_spaces : int -> unit;\n}\n;;\n\nlet pp_set_formatter_out_functions state {\n out_string = f;\n out_flush = g;\n out_newline = h;\n out_spaces = i;\n } =\n state.pp_out_string <- f;\n state.pp_out_flush <- g;\n state.pp_out_newline <- h;\n state.pp_out_spaces <- i;\n;;\n\nlet pp_get_formatter_out_functions state () = {\n out_string = state.pp_out_string;\n out_flush = state.pp_out_flush;\n out_newline = state.pp_out_newline;\n out_spaces = state.pp_out_spaces;\n}\n;;\n\nlet pp_set_formatter_output_functions state f g =\n state.pp_out_string <- f; state.pp_out_flush <- g;;\nlet pp_get_formatter_output_functions state () =\n (state.pp_out_string, state.pp_out_flush)\n;;\n\nlet pp_set_all_formatter_output_functions state\n ~out:f ~flush:g ~newline:h ~spaces:i =\n pp_set_formatter_output_functions state f g;\n state.pp_out_newline <- h;\n state.pp_out_spaces <- i;\n;;\nlet pp_get_all_formatter_output_functions state () =\n (state.pp_out_string, state.pp_out_flush,\n state.pp_out_newline, state.pp_out_spaces)\n;;\n\n(* Default function to output new lines. *)\nlet display_newline state () = state.pp_out_string \"\\n\" 0 1;;\n\n(* Default function to output spaces. *)\nlet blank_line = String.make 80 ' ';;\nlet rec display_blanks state n =\n if n > 0 then\n if n <= 80 then state.pp_out_string blank_line 0 n else\n begin\n state.pp_out_string blank_line 0 80;\n display_blanks state (n - 80)\n end\n;;\n\nlet pp_set_formatter_out_channel state os =\n state.pp_out_string <- output_substring os;\n state.pp_out_flush <- (fun () -> flush os);\n state.pp_out_newline <- display_newline state;\n state.pp_out_spaces <- display_blanks state;\n;;\n\n(**************************************************************\n\n Creation of specific formatters\n\n **************************************************************)\n\nlet default_pp_mark_open_tag s = \"<\" ^ s ^ \">\";;\nlet default_pp_mark_close_tag s = \"\";;\n\nlet default_pp_print_open_tag = ignore;;\nlet default_pp_print_close_tag = ignore;;\n\nlet pp_make_formatter f g h i =\n (* The initial state of the formatter contains a dummy box. *)\n let pp_q = make_queue () in\n let sys_tok =\n make_queue_elem (size_of_int (-1)) (Pp_begin (0, Pp_hovbox)) 0 in\n add_queue sys_tok pp_q;\n let sys_scan_stack =\n (Scan_elem (1, sys_tok)) :: scan_stack_bottom in\n {\n pp_scan_stack = sys_scan_stack;\n pp_format_stack = [];\n pp_tbox_stack = [];\n pp_tag_stack = [];\n pp_mark_stack = [];\n pp_margin = 78;\n pp_min_space_left = 10;\n pp_max_indent = 78 - 10;\n pp_space_left = 78;\n pp_current_indent = 0;\n pp_is_new_line = true;\n pp_left_total = 1;\n pp_right_total = 1;\n pp_curr_depth = 1;\n pp_max_boxes = max_int;\n pp_ellipsis = \".\";\n pp_out_string = f;\n pp_out_flush = g;\n pp_out_newline = h;\n pp_out_spaces = i;\n pp_print_tags = false;\n pp_mark_tags = false;\n pp_mark_open_tag = default_pp_mark_open_tag;\n pp_mark_close_tag = default_pp_mark_close_tag;\n pp_print_open_tag = default_pp_print_open_tag;\n pp_print_close_tag = default_pp_print_close_tag;\n pp_queue = pp_q;\n }\n;;\n\n(* Make a formatter with default functions to output spaces and new lines. *)\nlet make_formatter output flush =\n let ppf = pp_make_formatter output flush ignore ignore in\n ppf.pp_out_newline <- display_newline ppf;\n ppf.pp_out_spaces <- display_blanks ppf;\n ppf\n;;\n\nlet formatter_of_out_channel oc =\n make_formatter (output_substring oc) (fun () -> flush oc)\n;;\n\nlet formatter_of_buffer b =\n make_formatter (Buffer.add_substring b) ignore\n;;\n\nlet stdbuf = Buffer.create 512;;\n\n(* Predefined formatters. *)\nlet std_formatter = formatter_of_out_channel Pervasives.stdout\nand err_formatter = formatter_of_out_channel Pervasives.stderr\nand str_formatter = formatter_of_buffer stdbuf\n;;\n\nlet flush_str_formatter () =\n pp_flush_queue str_formatter false;\n let s = Buffer.contents stdbuf in\n Buffer.reset stdbuf;\n s\n;;\n\nlet flush_buf_formatter buf ppf =\n pp_flush_queue ppf false;\n let s = Buffer.contents buf in\n Buffer.reset buf;\n s\n\n(**************************************************************\n\n Basic functions on the standard formatter\n\n **************************************************************)\n\nlet open_hbox = pp_open_hbox std_formatter\nand open_vbox = pp_open_vbox std_formatter\nand open_hvbox = pp_open_hvbox std_formatter\nand open_hovbox = pp_open_hovbox std_formatter\nand open_box = pp_open_box std_formatter\nand close_box = pp_close_box std_formatter\nand open_tag = pp_open_tag std_formatter\nand close_tag = pp_close_tag std_formatter\nand print_as = pp_print_as std_formatter\nand print_string = pp_print_string std_formatter\nand print_int = pp_print_int std_formatter\nand print_float = pp_print_float std_formatter\nand print_char = pp_print_char std_formatter\nand print_bool = pp_print_bool std_formatter\nand print_break = pp_print_break std_formatter\nand print_cut = pp_print_cut std_formatter\nand print_space = pp_print_space std_formatter\nand force_newline = pp_force_newline std_formatter\nand print_flush = pp_print_flush std_formatter\nand print_newline = pp_print_newline std_formatter\nand print_if_newline = pp_print_if_newline std_formatter\n\nand open_tbox = pp_open_tbox std_formatter\nand close_tbox = pp_close_tbox std_formatter\nand print_tbreak = pp_print_tbreak std_formatter\n\nand set_tab = pp_set_tab std_formatter\nand print_tab = pp_print_tab std_formatter\n\nand set_margin = pp_set_margin std_formatter\nand get_margin = pp_get_margin std_formatter\n\nand set_max_indent = pp_set_max_indent std_formatter\nand get_max_indent = pp_get_max_indent std_formatter\n\nand set_max_boxes = pp_set_max_boxes std_formatter\nand get_max_boxes = pp_get_max_boxes std_formatter\nand over_max_boxes = pp_over_max_boxes std_formatter\n\nand set_ellipsis_text = pp_set_ellipsis_text std_formatter\nand get_ellipsis_text = pp_get_ellipsis_text std_formatter\n\nand set_formatter_out_channel =\n pp_set_formatter_out_channel std_formatter\n\nand set_formatter_out_functions =\n pp_set_formatter_out_functions std_formatter\nand get_formatter_out_functions =\n pp_get_formatter_out_functions std_formatter\n\nand set_formatter_output_functions =\n pp_set_formatter_output_functions std_formatter\nand get_formatter_output_functions =\n pp_get_formatter_output_functions std_formatter\n\nand set_all_formatter_output_functions =\n pp_set_all_formatter_output_functions std_formatter\nand get_all_formatter_output_functions =\n pp_get_all_formatter_output_functions std_formatter\n\nand set_formatter_tag_functions =\n pp_set_formatter_tag_functions std_formatter\nand get_formatter_tag_functions =\n pp_get_formatter_tag_functions std_formatter\nand set_print_tags =\n pp_set_print_tags std_formatter\nand get_print_tags =\n pp_get_print_tags std_formatter\nand set_mark_tags =\n pp_set_mark_tags std_formatter\nand get_mark_tags =\n pp_get_mark_tags std_formatter\nand set_tags =\n pp_set_tags std_formatter\n;;\n\n (**************************************************************)\n\nlet compute_tag output tag_acc =\n let buf = Buffer.create 16 in\n let ppf = formatter_of_buffer buf in\n let () = output ppf tag_acc in\n let () = pp_print_flush ppf () in\n let len = Buffer.length buf in\n if len < 2 then Buffer.contents buf\n else Buffer.sub buf 1 (len - 2)\n\n (**************************************************************\n\n Defining continuations to be passed as arguments of\n CamlinternalFormat.make_printf.\n\n **************************************************************)\n\nopen CamlinternalFormatBasics\nopen CamlinternalFormat\n\n(* Interpret a formatting entity on a formatter. *)\nlet output_formatting_lit ppf fmting_lit = match fmting_lit with\n | Close_box -> pp_close_box ppf ()\n | Close_tag -> pp_close_tag ppf ()\n | Break (_, width, offset) -> pp_print_break ppf width offset\n | FFlush -> pp_print_flush ppf ()\n | Force_newline -> pp_force_newline ppf ()\n | Flush_newline -> pp_print_newline ppf ()\n | Magic_size (_, _) -> ()\n | Escaped_at -> pp_print_char ppf '@'\n | Escaped_percent -> pp_print_char ppf '%'\n | Scan_indic c -> pp_print_char ppf '@'; pp_print_char ppf c\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in an output_stream. *)\n(* Differ from Printf.output_acc by the interpretation of formatting. *)\n(* Used as a continuation of CamlinternalFormat.make_printf. *)\nlet rec output_acc ppf acc = match acc with\n | Acc_string_literal (Acc_formatting_lit (p, Magic_size (_, size)), s)\n | Acc_data_string (Acc_formatting_lit (p, Magic_size (_, size)), s) ->\n output_acc ppf p;\n pp_print_as_size ppf (size_of_int size) s;\n | Acc_char_literal (Acc_formatting_lit (p, Magic_size (_, size)), c)\n | Acc_data_char (Acc_formatting_lit (p, Magic_size (_, size)), c) ->\n output_acc ppf p;\n pp_print_as_size ppf (size_of_int size) (String.make 1 c);\n | Acc_formatting_lit (p, f) ->\n output_acc ppf p;\n output_formatting_lit ppf f;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n output_acc ppf p;\n pp_open_tag ppf (compute_tag output_acc acc')\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n let () = output_acc ppf p in\n let (indent, bty) = open_box_of_string (compute_tag output_acc acc') in\n pp_open_box_gen ppf indent bty\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> output_acc ppf p; pp_print_string ppf s;\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> output_acc ppf p; pp_print_char ppf c;\n | Acc_delay (p, f) -> output_acc ppf p; f ppf;\n | Acc_flush p -> output_acc ppf p; pp_print_flush ppf ();\n | Acc_invalid_arg (p, msg) -> output_acc ppf p; invalid_arg msg;\n | End_of_acc -> ()\n\n(* Recursively output an \"accumulator\" containing a reversed list of\n printing entities (string, char, flus, ...) in a buffer. *)\n(* Differ from Printf.bufput_acc by the interpretation of formatting. *)\n(* Used as a continuation of CamlinternalFormat.make_printf. *)\nlet rec strput_acc ppf acc = match acc with\n | Acc_string_literal (Acc_formatting_lit (p, Magic_size (_, size)), s)\n | Acc_data_string (Acc_formatting_lit (p, Magic_size (_, size)), s) ->\n strput_acc ppf p;\n pp_print_as_size ppf (size_of_int size) s;\n | Acc_char_literal (Acc_formatting_lit (p, Magic_size (_, size)), c)\n | Acc_data_char (Acc_formatting_lit (p, Magic_size (_, size)), c) ->\n strput_acc ppf p;\n pp_print_as_size ppf (size_of_int size) (String.make 1 c);\n | Acc_delay (Acc_formatting_lit (p, Magic_size (_, size)), f) ->\n strput_acc ppf p;\n pp_print_as_size ppf (size_of_int size) (f ());\n | Acc_formatting_lit (p, f) ->\n strput_acc ppf p;\n output_formatting_lit ppf f;\n | Acc_formatting_gen (p, Acc_open_tag acc') ->\n strput_acc ppf p;\n pp_open_tag ppf (compute_tag strput_acc acc')\n | Acc_formatting_gen (p, Acc_open_box acc') ->\n let () = strput_acc ppf p in\n let (indent, bty) = open_box_of_string (compute_tag strput_acc acc') in\n pp_open_box_gen ppf indent bty\n | Acc_string_literal (p, s)\n | Acc_data_string (p, s) -> strput_acc ppf p; pp_print_string ppf s;\n | Acc_char_literal (p, c)\n | Acc_data_char (p, c) -> strput_acc ppf p; pp_print_char ppf c;\n | Acc_delay (p, f) -> strput_acc ppf p; pp_print_string ppf (f ());\n | Acc_flush p -> strput_acc ppf p; pp_print_flush ppf ();\n | Acc_invalid_arg (p, msg) -> strput_acc ppf p; invalid_arg msg;\n | End_of_acc -> ()\n\n(**************************************************************\n\n Defining [fprintf] and various flavors of [fprintf].\n\n **************************************************************)\n\nlet kfprintf k o (Format (fmt, _)) =\n make_printf (fun o acc -> output_acc o acc; k o) o End_of_acc fmt\nlet ikfprintf k x (Format (fmt, _)) =\n make_printf (fun _ _ -> k x) x End_of_acc fmt\n\nlet fprintf ppf fmt = kfprintf ignore ppf fmt\nlet ifprintf ppf fmt = ikfprintf ignore ppf fmt\nlet printf fmt = fprintf std_formatter fmt\nlet eprintf fmt = fprintf err_formatter fmt\n\nlet ksprintf k (Format (fmt, _)) =\n let b = Buffer.create 512 in\n let ppf = formatter_of_buffer b in\n let k' () acc =\n strput_acc ppf acc;\n k (flush_buf_formatter b ppf) in\n make_printf k' () End_of_acc fmt\n\nlet sprintf fmt =\n ksprintf (fun s -> s) fmt\n\nlet asprintf (Format (fmt, _)) =\n let b = Buffer.create 512 in\n let ppf = formatter_of_buffer b in\n let k' : (formatter -> (formatter, unit) acc -> string)\n = fun ppf acc ->\n output_acc ppf acc;\n pp_flush_queue ppf false;\n flush_buf_formatter b ppf in\n make_printf k' ppf End_of_acc fmt\n\n(**************************************************************\n\n Deprecated stuff.\n\n **************************************************************)\n\n(* Deprecated error prone function bprintf. *)\nlet bprintf b (Format (fmt, _) : ('a, formatter, unit) format) =\n let k ppf acc = output_acc ppf acc; pp_flush_queue ppf false in\n make_printf k (formatter_of_buffer b) End_of_acc fmt\n\n(* Deprecated alias for ksprintf. *)\nlet kprintf = ksprintf;;\n\n(* Output everything left in the pretty printer queue at end of execution. *)\nat_exit print_flush\n;;\n", "(* Js_of_ocaml library\n * http://www.ocsigen.org/js_of_ocaml/\n * Copyright (C) 2010 Jérôme Vouillon\n * Laboratoire PPS - CNRS Université Paris Diderot\n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, with linking exception;\n * either version 2.1 of the License, or (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n *)\n\ntype +'a t\n\ntype (-'a, +'b) meth_callback\n\nmodule Unsafe = struct\n type any\n external inject : 'a -> any = \"%identity\"\n external coerce : _ t -> _ t = \"%identity\"\n\n external get : 'a -> 'b -> 'c = \"caml_js_get\"\n external set : 'a -> 'b -> 'c -> unit = \"caml_js_set\"\n external delete : 'a -> 'b -> unit = \"caml_js_delete\"\n external call : 'a -> 'b -> any array -> 'c = \"caml_js_call\"\n external fun_call : 'a -> any array -> 'b = \"caml_js_fun_call\"\n external meth_call : 'a -> string -> any array -> 'b = \"caml_js_meth_call\"\n external new_obj : 'a -> any array -> 'b = \"caml_js_new\"\n\n external obj : (string * any) array -> 'a = \"caml_js_object\"\n\n external equals : 'a -> 'b -> bool = \"caml_js_equals\"\n\n external pure_expr : (unit -> 'a) -> 'a = \"caml_js_pure_expr\"\n\n external eval_string : string -> 'a = \"caml_js_eval_string\"\n\n external js_expr : string -> 'a = \"caml_js_expr\"\n\n external pure_js_expr : string -> 'a = \"caml_pure_js_expr\"\n\n let global = pure_js_expr \"joo_global_object\"\n\n external callback : ('a -> 'b) -> ('c, 'a -> 'b) meth_callback = \"%identity\"\n external meth_callback : ('b -> 'a) -> ('b, 'a) meth_callback = \"caml_js_wrap_meth_callback_unsafe\"\n\n (* DEPRECATED *)\n external variable : string -> 'a = \"caml_js_var\"\nend\n\n(****)\n\ntype 'a opt = 'a\ntype 'a optdef = 'a\n\nexternal debugger : unit -> unit = \"debugger\"\n\nlet null : 'a opt = Unsafe.pure_js_expr \"null\"\nexternal some : 'a -> 'a opt = \"%identity\"\n\nlet undefined : 'a optdef = Unsafe.pure_js_expr \"undefined\"\nexternal def : 'a -> 'a optdef = \"%identity\"\n\nmodule type OPT = sig\n type 'a t\n val empty : 'a t\n val return : 'a -> 'a t\n val map : 'a t -> ('a -> 'b) -> 'b t\n val bind : 'a t -> ('a -> 'b t) -> 'b t\n val test : 'a t -> bool\n val iter : 'a t -> ('a -> unit) -> unit\n val case : 'a t -> (unit -> 'b) -> ('a -> 'b) -> 'b\n val get : 'a t -> (unit -> 'a) -> 'a\n val option : 'a option -> 'a t\n val to_option : 'a t -> 'a option\nend\n\nmodule Opt : OPT with type 'a t = 'a opt = struct\n type 'a t = 'a opt\n let empty = null\n let return = some\n let map x f = if Unsafe.equals x null then null else some (f x)\n let bind x f = if Unsafe.equals x null then null else f x\n let test x = not (Unsafe.equals x null)\n let iter x f = if not (Unsafe.equals x null) then f x\n let case x f g = if Unsafe.equals x null then f () else g x\n let get x f = if Unsafe.equals x null then f () else x\n let option x = match x with None -> empty | Some x -> return x\n let to_option x = case x (fun () -> None) (fun x -> Some x)\nend\n\nmodule Optdef : OPT with type 'a t = 'a optdef = struct\n type 'a t = 'a opt\n let empty = undefined\n let return = def\n let map x f = if x == undefined then undefined else some (f x)\n let bind x f = if x == undefined then undefined else f x\n let test x = x != undefined\n let iter x f = if x != undefined then f x\n let case x f g = if x == undefined then f () else g x\n let get x f = if x == undefined then f () else x\n let option x = match x with None -> empty | Some x -> return x\n let to_option x = case x (fun () -> None) (fun x -> Some x)\nend\n\n(****)\n\nlet coerce x f g = Opt.get (f x) (fun () -> g x)\nlet coerce_opt x f g = Opt.get (Opt.bind x f) (fun () -> g x)\n\n(****)\n\ntype +'a meth\ntype +'a gen_prop\ntype 'a readonly_prop = gen_prop\ntype 'a writeonly_prop = unit> gen_prop\ntype 'a prop = unit> gen_prop\ntype 'a optdef_prop = unit> gen_prop\n\ntype +'a constr\n\n(****)\n\ntype 'a callback = (unit, 'a) meth_callback\n\nexternal wrap_callback : ('a -> 'b) -> ('c, 'a -> 'b) meth_callback = \"caml_js_wrap_callback\"\nexternal wrap_meth_callback : ('a -> 'b) -> ('a, 'b) meth_callback = \"caml_js_wrap_meth_callback\"\n\n(****)\n\nlet _true = Unsafe.pure_js_expr \"true\"\nlet _false = Unsafe.pure_js_expr \"false\"\n\ntype match_result_handle\ntype string_array\n\nclass type js_string = object\n method toString : js_string t meth\n method valueOf : js_string t meth\n method charAt : int -> js_string t meth\n method charCodeAt : int -> float meth (* This may return NaN... *)\n method concat : js_string t -> js_string t meth\n method concat_2 : js_string t -> js_string t -> js_string t meth\n method concat_3 :\n js_string t -> js_string t -> js_string t -> js_string t meth\n method concat_4 :\n js_string t -> js_string t -> js_string t -> js_string t ->\n js_string t meth\n method indexOf : js_string t -> int meth\n method indexOf_from : js_string t -> int -> int meth\n method lastIndexOf : js_string t -> int meth\n method lastIndexOf_from : js_string t -> int -> int meth\n method localeCompare : js_string t -> float meth\n method _match : regExp t -> match_result_handle t opt meth\n method replace : regExp t -> js_string t -> js_string t meth\n method replace_string : js_string t -> js_string t -> js_string t meth\n method search : regExp t -> int meth\n method slice : int -> int -> js_string t meth\n method slice_end : int -> js_string t meth\n method split : js_string t -> string_array t meth\n method split_limited : js_string t -> int -> string_array t meth\n method split_regExp : regExp t -> string_array t meth\n method split_regExpLimited : regExp t -> int -> string_array t meth\n method substring : int -> int -> js_string t meth\n method substring_toEnd : int -> js_string t meth\n method toLowerCase : js_string t meth\n method toLocaleLowerCase : js_string t meth\n method toUpperCase : js_string t meth\n method toLocaleUpperCase : js_string t meth\n method trim : js_string t meth\n method length : int readonly_prop\nend\n\nand regExp = object\n method exec : js_string t -> match_result_handle t opt meth\n method test : js_string t -> bool t meth\n method toString : js_string t meth\n method source : js_string t readonly_prop\n method global : bool t readonly_prop\n method ignoreCase : bool t readonly_prop\n method multiline : bool t readonly_prop\n method lastIndex : int prop\nend\n\nclass type string_constr = object\n method fromCharCode : int -> js_string t meth\nend\n\nlet string_constr = Unsafe.global##_String\n\nlet regExp = Unsafe.global##_RegExp\nlet regExp_copy = regExp\nlet regExp_withFlags = regExp\n\nclass type ['a] js_array = object\n method toString : js_string t meth\n method toLocaleString : js_string t meth\n method concat : 'a js_array t -> 'a js_array t meth\n method join : js_string t -> js_string t meth\n method pop : 'a optdef meth\n method push : 'a -> int meth\n method push_2 : 'a -> 'a -> int meth\n method push_3 : 'a -> 'a -> 'a -> int meth\n method push_4 : 'a -> 'a -> 'a -> 'a -> int meth\n method reverse : 'a js_array t meth\n method shift : 'a optdef meth\n method slice : int -> int -> 'a js_array t meth\n method slice_end : int -> 'a js_array t meth\n method sort : ('a -> 'a -> float) callback -> 'a js_array t meth\n method sort_asStrings : 'a js_array t meth\n method splice : int -> int -> 'a js_array t meth\n method splice_1 : int -> int -> 'a -> 'a js_array t meth\n method splice_2 : int -> int -> 'a -> 'a -> 'a js_array t meth\n method splice_3 : int -> int -> 'a -> 'a -> 'a -> 'a js_array t meth\n method splice_4 : int -> int -> 'a -> 'a -> 'a -> 'a -> 'a js_array t meth\n method unshift : 'a -> int meth\n method unshift_2 : 'a -> 'a -> int meth\n method unshift_3 : 'a -> 'a -> 'a -> int meth\n method unshift_4 : 'a -> 'a -> 'a -> 'a -> int meth\n\n method some : ('a -> int -> 'a js_array t -> bool t ) callback -> bool t meth\n method every : ('a -> int -> 'a js_array t -> bool t ) callback -> bool t meth\n method forEach : ('a -> int -> 'a js_array t -> unit ) callback -> unit meth\n method map : ('a -> int -> 'a js_array t -> 'b) callback -> 'b js_array t meth\n method filter : ('a -> int -> 'a js_array t -> bool t) callback -> 'a js_array t meth\n method reduce_init : ('b -> 'a -> int -> 'a js_array t -> 'b) callback -> 'b -> 'b meth\n method reduce : ('a -> 'a -> int -> 'a js_array t -> 'a) callback -> 'a meth\n method reduceRight_init : ('b -> 'a -> int -> 'a js_array t -> 'b) callback -> 'b -> 'b meth\n method reduceRight : ('a -> 'a -> int -> 'a js_array t -> 'a) callback -> 'a meth\n\n method length : int prop\nend\n\nlet object_constructor = Unsafe.global##_Object\nlet object_keys o = object_constructor##keys(o)\n\nlet array_constructor = Unsafe.global##_Array\nlet array_empty = array_constructor\nlet array_length = array_constructor\n\nlet array_get : 'a #js_array t -> int -> 'a optdef = Unsafe.get\nlet array_set : 'a #js_array t -> int -> 'a -> unit = Unsafe.set\n\nlet array_map_poly :\n 'a #js_array t ->\n ('a -> int -> 'a #js_array t -> 'b) callback ->\n 'b #js_array t = fun a cb -> (Unsafe.coerce a)##map(cb)\n\nlet array_map f a = array_map_poly a (wrap_callback (fun x _idx _ -> f x))\nlet array_mapi f a = array_map_poly a (wrap_callback (fun x idx _ -> f idx x))\n\nclass type match_result = object\n inherit [js_string t] js_array\n method index : int readonly_prop\n method input : js_string t readonly_prop\nend\n\nlet str_array : string_array t -> js_string t js_array t = Unsafe.coerce\nlet match_result : match_result_handle t -> match_result t =\n Unsafe.coerce\n\nclass type number = object\n method toString : js_string t meth\n method toString_radix : int -> js_string t meth\n method toLocaleString : js_string t meth\n method toFixed : int -> js_string t meth\n method toExponential : js_string t meth\n method toExponential_digits : int -> js_string t meth\n method toPrecision : int -> js_string t meth\nend\n\nexternal number_of_float : float -> number t = \"caml_js_from_float\"\nexternal float_of_number : number t -> float = \"caml_js_to_float\"\n\nclass type date = object\n method toString : js_string t meth\n method toDateString : js_string t meth\n method toTimeString : js_string t meth\n method toLocaleString : js_string t meth\n method toLocaleDateString : js_string t meth\n method toLocaleTimeString : js_string t meth\n method valueOf : float meth\n method getTime : float meth\n method getFullYear : int meth\n method getUTCFullYear : int meth\n method getMonth : int meth\n method getUTCMonth : int meth\n method getDate : int meth\n method getUTCDate : int meth\n method getDay : int meth\n method getUTCDay : int meth\n method getHours : int meth\n method getUTCHours : int meth\n method getMinutes : int meth\n method getUTCMinutes : int meth\n method getSeconds : int meth\n method getUTCSeconds : int meth\n method getMilliseconds : int meth\n method getUTCMilliseconds : int meth\n method getTimezoneOffset : int meth\n method setTime : float -> float meth\n method setFullYear : int -> float meth\n method setUTCFullYear : int -> float meth\n method setMonth : int -> float meth\n method setUTCMonth : int -> float meth\n method setDate : int -> float meth\n method setUTCDate : int -> float meth\n method setDay : int -> float meth\n method setUTCDay : int -> float meth\n method setHours : int -> float meth\n method setUTCHours : int -> float meth\n method setMinutes : int -> float meth\n method setUTCMinutes : int -> float meth\n method setSeconds : int -> float meth\n method setUTCSeconds : int -> float meth\n method setMilliseconds : int -> float meth\n method setUTCMilliseconds : int -> float meth\n method toUTCString : js_string t meth\n method toISOString : js_string t meth\n method toJSON : 'a -> js_string t meth\nend\n\nclass type date_constr = object\n method parse : js_string t -> float meth\n method _UTC_month : int -> int -> float meth\n method _UTC_day : int -> int -> float meth\n method _UTC_hour : int -> int -> int -> int -> float meth\n method _UTC_min : int -> int -> int -> int -> int -> float meth\n method _UTC_sec : int -> int -> int -> int -> int -> int -> float meth\n method _UTC_ms :\n int -> int -> int -> int -> int -> int -> int -> float meth\n(*\n method now : float meth\n*)\nend\n\nlet date_constr = Unsafe.global##_Date\nlet date : date_constr t = date_constr\nlet date_now : date t constr = date_constr\nlet date_fromTimeValue : (float -> date t) constr = date_constr\nlet date_month : (int -> int -> date t) constr = date_constr\nlet date_day : (int -> int -> int -> date t) constr = date_constr\nlet date_hour : (int -> int -> int -> int -> date t) constr = date_constr\nlet date_min : (int -> int -> int -> int -> int -> date t) constr = date_constr\nlet date_sec : (int -> int -> int -> int -> int -> int -> date t) constr =\n date_constr\nlet date_ms :\n (int -> int -> int -> int -> int -> int -> int -> date t) constr =\n date_constr\n\nclass type math = object\n method _E : float readonly_prop\n method _LN2 : float readonly_prop\n method _LN10 : float readonly_prop\n method _LOG2E : float readonly_prop\n method _LOG10E : float readonly_prop\n method _PI : float readonly_prop\n method _SQRT1_2_ : float readonly_prop\n method _SQRT2 : float readonly_prop\n method abs : float -> float meth\n method acos : float -> float meth\n method asin : float -> float meth\n method atan : float -> float meth\n method atan2 : float -> float -> float meth\n method ceil : float -> float meth\n method cos : float -> float meth\n method exp : float -> float meth\n method floor : float -> float meth\n method log : float -> float meth\n method max : float -> float -> float meth\n method max_3 : float -> float -> float -> float meth\n method max_4 : float -> float -> float -> float -> float meth\n method min : float -> float -> float meth\n method min_3 : float -> float -> float -> float meth\n method min_4 : float -> float -> float -> float -> float meth\n method pow : float -> float -> float meth\n method random : float meth\n method round : float -> float meth\n method sin : float -> float meth\n method sqrt : float -> float meth\n method tan : float -> float meth\nend\n\nlet math = Unsafe.global##_Math\n\n\nclass type error = object\n method name : js_string t prop\n method message : js_string t prop\n method stack : js_string t optdef prop\n method toString : js_string t meth\nend\n\nexception Error of error t\nlet error_constr = Unsafe.global##_Error\nlet _ = Callback.register_exception \"jsError\" (Error (Unsafe.obj [||]))\n\nlet raise_js_error = ((Unsafe.js_expr \"(function (exn) { throw exn })\") : error t -> 'a)\n\nclass type json = object\n method parse : js_string t -> 'a meth\n method stringify: 'a -> js_string t meth\nend\n\nlet _JSON : json t = Unsafe.global##_JSON\n\n\nlet decodeURI (s : js_string t) : js_string t =\n Unsafe.fun_call (Unsafe.global##decodeURI) [|Unsafe.inject s|]\nlet decodeURIComponent (s : js_string t) : js_string t =\n Unsafe.fun_call (Unsafe.global##decodeURIComponent) [|Unsafe.inject s|]\nlet encodeURI (s : js_string t) : js_string t =\n Unsafe.fun_call (Unsafe.global##encodeURI) [|Unsafe.inject s|]\nlet encodeURIComponent (s : js_string t) : js_string t =\n Unsafe.fun_call (Unsafe.global##encodeURIComponent) [|Unsafe.inject s|]\nlet escape (s : js_string t) : js_string t =\n Unsafe.fun_call (Unsafe.global##escape) [|Unsafe.inject s|]\nlet unescape (s : js_string t) : js_string t =\n Unsafe.fun_call (Unsafe.global##unescape) [|Unsafe.inject s|]\n\nexternal bool : bool -> bool t = \"caml_js_from_bool\"\nexternal to_bool : bool t -> bool = \"caml_js_to_bool\"\nexternal string : string -> js_string t = \"caml_js_from_string\"\nexternal to_string : js_string t -> string = \"caml_js_to_string\"\nexternal array : 'a array -> 'a js_array t = \"caml_js_from_array\"\nexternal to_array : 'a js_array t -> 'a array = \"caml_js_to_array\"\nexternal bytestring : string -> js_string t = \"caml_bytes_of_string\"\nexternal to_bytestring : js_string t -> string = \"caml_js_to_byte_string\"\n\nexternal typeof : _ t -> js_string t = \"caml_js_typeof\"\nexternal instanceof : _ t -> _ constr -> bool = \"caml_js_instanceof\"\n\nlet isNaN (i : 'a) : bool =\n to_bool (Unsafe.fun_call (Unsafe.global##isNaN) [|Unsafe.inject i|])\n\nlet parseInt (s : js_string t) : int =\n let s = Unsafe.fun_call (Unsafe.global##parseInt) [|Unsafe.inject s|] in\n if isNaN s\n then failwith \"parseInt\"\n else s\n\nlet parseFloat (s : js_string t) : float =\n let s = Unsafe.fun_call (Unsafe.global##parseFloat) [|Unsafe.inject s|] in\n if isNaN s\n then failwith \"parseFloat\"\n else s\n\nlet _ =\n Printexc.register_printer\n (function Error e -> Some (to_string (e##toString ())) | _ -> None)\nlet _ =\n Printexc.register_printer\n (fun e ->\n let e : < .. > t = Obj.magic e in\n if instanceof e array_constructor then None\n else Some (to_string (e##toString())))\n\nlet string_of_error e = to_string (e##toString())\n\nlet export_js (field : js_string t) x =\n let dest =\n let module_ = Unsafe.variable \"module\" in\n if Optdef.test module_\n && Optdef.test module_##exports\n then module_##exports\n else Unsafe.global\n in\n Unsafe.set dest field x\n\nlet export field x = export_js (string field) x\nlet export_all obj =\n let keys = object_keys obj in\n keys##forEach (wrap_callback (fun (key : js_string t) _ _ ->\n export_js key (Unsafe.get obj key)\n ))\n\n(****)\n\n(* DEPRECATED *)\n\ntype float_prop = float prop\nexternal float : float -> float = \"%identity\"\nexternal to_float : float -> float = \"%identity\"\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* Registering OCaml values with the C runtime for later callbacks *)\n\nexternal register_named_value : string -> Obj.t -> unit\n = \"caml_register_named_value\"\n\nlet register name v =\n register_named_value name (Obj.repr v)\n\nlet register_exception name (exn : exn) =\n let exn = Obj.repr exn in\n let slot = if Obj.tag exn = Obj.object_tag then exn else Obj.field exn 0 in\n register_named_value name slot\n", "type type_id = int\n\nlet dummy_type_id = 0\n\nlet create_type_id =\n let n = ref dummy_type_id in\n fun () ->\n incr n;\n if !n < 0 then\n failwith \"Bi_share.Rd_poly.create_type_id: \\\n exhausted available type_id's\"\n else\n !n\n\nmodule Wr =\nstruct\n module H = Hashtbl.Make (\n struct\n type t = Obj.t * type_id\n let equal (x1, t1) (x2, t2) = x1 == x2 && t1 == t2\n let hash = Hashtbl.hash\n end\n )\n\n type tbl = int H.t\n\n let create = H.create\n let clear tbl =\n if H.length tbl > 0 then\n H.clear tbl\n\n let put tbl k pos =\n try\n let pos0 = H.find tbl (Obj.magic k) in\n pos - pos0\n with Not_found ->\n H.add tbl (Obj.magic k) pos;\n 0\nend\n\nmodule Rd =\nstruct\n type tbl = ((int * type_id), Obj.t) Hashtbl.t\n\n let create n = Hashtbl.create n\n let clear = Hashtbl.clear\n\n let put tbl pos x =\n Hashtbl.add tbl pos x\n\n let get tbl pos =\n try Hashtbl.find tbl pos\n with Not_found ->\n Bi_util.error \"Corrupted data (invalid reference)\"\nend\n", "type t = {\n mutable o_s : string;\n mutable o_max_len : int;\n mutable o_len : int;\n mutable o_offs : int;\n o_init_len : int;\n o_make_room : (t -> int -> unit);\n mutable o_shared : Bi_share.Wr.tbl;\n o_shared_init_len : int;\n}\n\nlet really_extend b n =\n let slen0 = b.o_max_len in\n let reqlen = b.o_len + n in\n let slen =\n let x = max reqlen (2 * slen0) in\n if x <= Sys.max_string_length then x\n else\n if Sys.max_string_length < reqlen then\n\u0009invalid_arg \"Buf.extend: reached Sys.max_string_length\"\n else\n\u0009Sys.max_string_length\n in\n let s = String.create slen in\n String.blit b.o_s 0 s 0 b.o_len;\n b.o_s <- s;\n b.o_max_len <- slen\n\nlet flush_to_output abstract_output b n =\n abstract_output b.o_s 0 b.o_len;\n b.o_offs <- b.o_offs + b.o_len;\n b.o_len <- 0;\n if n > b.o_max_len then\n really_extend b n\n\nlet flush_to_channel oc = flush_to_output (output oc)\n\n\nlet create ?(make_room = really_extend) ?(shrlen = 16) n = {\n o_s = String.create n;\n o_max_len = n;\n o_len = 0;\n o_offs = 0;\n o_init_len = n;\n o_make_room = make_room;\n o_shared = Bi_share.Wr.create shrlen;\n o_shared_init_len = shrlen;\n}\n\nlet create_channel_writer ?(len = 4096) ?shrlen oc =\n create ~make_room:(flush_to_channel oc) ?shrlen len\n\nlet flush_channel_writer b =\n b.o_make_room b 0\n\nlet create_output_writer ?(len = 4096) ?shrlen out =\n create ~make_room:(flush_to_output out#output) ?shrlen len\n\nlet flush_output_writer = flush_channel_writer\n\n\n(*\n Guarantee that the buffer string has enough room for n additional bytes.\n*)\nlet extend b n =\n if b.o_len + n > b.o_max_len then\n b.o_make_room b n\n\nlet alloc b n =\n extend b n;\n let pos = b.o_len in\n b.o_len <- pos + n;\n pos\n\nlet add_substring b s pos len =\n extend b len;\n String.blit s pos b.o_s b.o_len len;\n b.o_len <- b.o_len + len\n\nlet add_string b s =\n add_substring b s 0 (String.length s)\n\n\nlet add_char b c =\n let pos = alloc b 1 in\n b.o_s.[pos] <- c\n\nlet unsafe_add_char b c =\n let len = b.o_len in\n b.o_s.[len] <- c;\n b.o_len <- len + 1\n\nlet add_char2 b c1 c2 =\n let pos = alloc b 2 in\n let s = b.o_s in\n String.unsafe_set s pos c1;\n String.unsafe_set s (pos+1) c2\n\nlet add_char4 b c1 c2 c3 c4 =\n let pos = alloc b 4 in\n let s = b.o_s in\n String.unsafe_set s pos c1;\n String.unsafe_set s (pos+1) c2;\n String.unsafe_set s (pos+2) c3;\n String.unsafe_set s (pos+3) c4\n\n\n\nlet clear b =\n b.o_offs <- 0;\n b.o_len <- 0;\n Bi_share.Wr.clear b.o_shared\n\nlet reset b =\n if String.length b.o_s <> b.o_init_len then\n b.o_s <- String.create b.o_init_len;\n b.o_offs <- 0;\n b.o_len <- 0;\n b.o_shared <- Bi_share.Wr.create b.o_shared_init_len\n\nlet contents b = String.sub b.o_s 0 b.o_len\n", "(* included: type.ml *)\n\nopen Bi_outbuf\n\nlet hex n =\n Char.chr (\n if n < 10 then n + 48\n else n + 87\n )\n\nlet write_special src start stop ob str =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n Bi_outbuf.add_string ob str;\n start := stop + 1\n\nlet write_control_char src start stop ob c =\n Bi_outbuf.add_substring ob src !start (stop - !start);\n let i = Bi_outbuf.alloc ob 6 in\n let dst = ob.o_s in\n String.blit \"\\\\u00\" 0 dst i 4;\n dst.[i+4] <- hex (Char.code c lsr 4);\n dst.[i+5] <- hex (Char.code c land 0xf);\n start := stop + 1\n\nlet finish_string src start ob =\n try\n Bi_outbuf.add_substring ob src !start (String.length src - !start)\n with _ ->\n Printf.eprintf \"src=%S start=%i len=%i\\n%!\"\n src !start (String.length src - !start);\n failwith \"oops\"\n\nlet write_string_body ob s =\n let start = ref 0 in\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '\"' -> write_special s start i ob \"\\\\\\\"\"\n | '\\\\' -> write_special s start i ob \"\\\\\\\\\"\n | '\\b' -> write_special s start i ob \"\\\\b\"\n | '\\012' -> write_special s start i ob \"\\\\f\"\n | '\\n' -> write_special s start i ob \"\\\\n\"\n | '\\r' -> write_special s start i ob \"\\\\r\"\n | '\\t' -> write_special s start i ob \"\\\\t\"\n | '\\x00'..'\\x1F'\n | '\\x7F' as c -> write_control_char s start i ob c\n | _ -> ()\n done;\n finish_string s start ob\n\nlet write_string ob s =\n Bi_outbuf.add_char ob '\"';\n write_string_body ob s;\n Bi_outbuf.add_char ob '\"'\n\nlet json_string_of_string s =\n let ob = Bi_outbuf.create 10 in\n write_string ob s;\n Bi_outbuf.contents ob\n\nlet test_string () =\n let s = String.create 256 in\n for i = 0 to 255 do\n s.[i] <- Char.chr i\n done;\n json_string_of_string s\n\n\nlet write_null ob () =\n Bi_outbuf.add_string ob \"null\"\n\nlet write_bool ob x =\n Bi_outbuf.add_string ob (if x then \"true\" else \"false\")\n\n\nlet max_digits =\n max\n (String.length (string_of_int max_int))\n (String.length (string_of_int min_int))\n\nlet dec n =\n Char.chr (n + 48)\n\nlet rec write_digits s pos x =\n if x = 0 then pos\n else\n let d = x mod 10 in\n let pos = write_digits s pos (x / 10) in\n s.[pos] <- dec (abs d);\n pos + 1\n\nlet write_int ob x =\n Bi_outbuf.extend ob max_digits;\n if x > 0 then\n ob.o_len <- write_digits ob.o_s ob.o_len x\n else if x < 0 then (\n let s = ob.o_s in\n let pos = ob.o_len in\n s.[pos] <- '-';\n ob.o_len <- write_digits s (pos + 1) x\n )\n else\n Bi_outbuf.add_char ob '0'\n\n\nlet json_string_of_int i =\n string_of_int i\n\n\n(*\n Ensure that the float is not printed as an int.\n This is not required by JSON, but useful in order to guarantee\n reversibility.\n*)\nlet float_needs_period s =\n try\n for i = 0 to String.length s - 1 do\n match s.[i] with\n '0'..'9' | '-' -> ()\n | _ -> raise Exit\n done;\n true\n with Exit ->\n false\n\n(*\n Both write_float_fast and write_float guarantee\n that a sufficient number of digits are printed in order to\n allow reversibility.\n\n The _fast version is faster but often produces unnecessarily long numbers.\n*)\nlet write_float_fast ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_normal_float_prec significant_figures ob x =\n let open Printf in\n let s =\n match significant_figures with\n 1 -> sprintf \"%.1g\" x\n | 2 -> sprintf \"%.2g\" x\n | 3 -> sprintf \"%.3g\" x\n | 4 -> sprintf \"%.4g\" x\n | 5 -> sprintf \"%.5g\" x\n | 6 -> sprintf \"%.6g\" x\n | 7 -> sprintf \"%.7g\" x\n | 8 -> sprintf \"%.8g\" x\n | 9 -> sprintf \"%.9g\" x\n | 10 -> sprintf \"%.10g\" x\n | 11 -> sprintf \"%.11g\" x\n | 12 -> sprintf \"%.12g\" x\n | 13 -> sprintf \"%.13g\" x\n | 14 -> sprintf \"%.14g\" x\n | 15 -> sprintf \"%.15g\" x\n | 16 -> sprintf \"%.16g\" x\n | _ -> sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n Bi_outbuf.add_string ob \"NaN\"\n | FP_infinite ->\n Bi_outbuf.add_string ob (if x > 0. then \"Infinity\" else \"-Infinity\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_float ob x;\n Bi_outbuf.contents ob\n\n\nlet write_std_float_fast ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s = Printf.sprintf \"%.17g\" x in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n let s1 = Printf.sprintf \"%.16g\" x in\n let s =\n if float_of_string s1 = x then s1\n else Printf.sprintf \"%.17g\" x\n in\n Bi_outbuf.add_string ob s;\n if float_needs_period s then\n Bi_outbuf.add_string ob \".0\"\n\nlet write_std_float_prec significant_figures ob x =\n match classify_float x with\n FP_nan ->\n json_error \"NaN value not allowed in standard JSON\"\n | FP_infinite ->\n json_error\n (if x > 0. then\n \"Infinity value not allowed in standard JSON\"\n else\n \"-Infinity value not allowed in standard JSON\")\n | _ ->\n write_normal_float_prec significant_figures ob x\n\nlet std_json_string_of_float x =\n let ob = Bi_outbuf.create 20 in\n write_std_float ob x;\n Bi_outbuf.contents ob\n\n\nlet test_float () =\n let l = [ 0.; 1.; -1. ] in\n let l = l @ List.map (fun x -> 2. *. x +. 1.) l in\n let l = l @ List.map (fun x -> x /. sqrt 2.) l in\n let l = l @ List.map (fun x -> x *. sqrt 3.) l in\n let l = l @ List.map cos l in\n let l = l @ List.map (fun x -> x *. 1.23e50) l in\n let l = l @ [ infinity; neg_infinity ] in\n List.iter (\n fun x ->\n let s = Printf.sprintf \"%.17g\" x in\n let y = float_of_string s in\n Printf.printf \"%g %g %S %B\\n\" x y s (x = y)\n )\n l\n\n(*\nlet () = test_float ()\n*)\n\nlet write_intlit = Bi_outbuf.add_string\nlet write_floatlit = Bi_outbuf.add_string\nlet write_stringlit = Bi_outbuf.add_string\n\nlet rec iter2_aux f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_sep x;\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet iter2 f_elt f_sep x = function\n [] -> ()\n | y :: l ->\n f_elt x y;\n iter2_aux f_elt f_sep x l\n\nlet f_sep ob =\n Bi_outbuf.add_char ob ','\n\nlet rec write_json ob (x : json) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n#ifdef INT\n | `Int i -> write_int ob i\n#endif\n#ifdef INTLIT\n | `Intlit s -> Bi_outbuf.add_string ob s\n#endif\n#ifdef FLOAT\n | `Float f -> write_float ob f\n#endif\n#ifdef FLOATLIT\n | `Floatlit s -> Bi_outbuf.add_string ob s\n#endif\n#ifdef STRING\n | `String s -> write_string ob s\n#endif\n#ifdef STRINGLIT\n | `Stringlit s -> Bi_outbuf.add_string ob s\n#endif\n | `Assoc l -> write_assoc ob l\n | `List l -> write_list ob l\n#ifdef TUPLE\n | `Tuple l -> write_tuple ob l\n#endif\n#ifdef VARIANT\n | `Variant (s, o) -> write_variant ob s o\n#endif\n\nand write_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n#ifdef TUPLE\nand write_tuple ob l =\n Bi_outbuf.add_char ob '(';\n iter2 write_json f_sep ob l;\n Bi_outbuf.add_char ob ')'\n#endif\n\n#ifdef VARIANT\nand write_variant ob s o =\n Bi_outbuf.add_char ob '<';\n write_string ob s;\n (match o with\n None -> ()\n | Some x ->\n Bi_outbuf.add_char ob ':';\n write_json ob x\n );\n Bi_outbuf.add_char ob '>'\n#endif\n\n\nlet rec write_std_json ob (x : json) =\n match x with\n `Null -> write_null ob ()\n | `Bool b -> write_bool ob b\n#ifdef INT\n | `Int i -> write_int ob i\n#endif\n#ifdef INTLIT\n | `Intlit s -> Bi_outbuf.add_string ob s\n#endif\n#ifdef FLOAT\n | `Float f -> write_std_float ob f\n#endif\n#ifdef FLOATLIT\n | `Floatlit s -> Bi_outbuf.add_string ob s\n#endif\n#ifdef STRING\n | `String s -> write_string ob s\n#endif\n#ifdef STRINGLIT\n | `Stringlit s -> Bi_outbuf.add_string ob s\n#endif\n | `Assoc l -> write_std_assoc ob l\n | `List l -> write_std_list ob l\n#ifdef TUPLE\n | `Tuple l -> write_std_tuple ob l\n#endif\n#ifdef VARIANT\n | `Variant (s, o) -> write_std_variant ob s o\n#endif\n\nand write_std_assoc ob l =\n let f_elt ob (s, x) =\n write_string ob s;\n Bi_outbuf.add_char ob ':';\n write_std_json ob x\n in\n Bi_outbuf.add_char ob '{';\n iter2 f_elt f_sep ob l;\n Bi_outbuf.add_char ob '}';\n\nand write_std_list ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\nand write_std_tuple ob l =\n Bi_outbuf.add_char ob '[';\n iter2 write_std_json f_sep ob l;\n Bi_outbuf.add_char ob ']'\n\n#ifdef VARIANT\nand write_std_variant ob s o =\n match o with\n None -> write_string ob s\n | Some x ->\n Bi_outbuf.add_char ob '[';\n write_string ob s;\n Bi_outbuf.add_char ob ',';\n write_std_json ob x;\n Bi_outbuf.add_char ob ']'\n#endif\n\n\nlet to_outbuf ?(std = false) ob x =\n if std then (\n if not (is_object_or_array x) then\n json_error \"Root is not an object or array\"\n else\n write_std_json ob x\n )\n else\n write_json ob x\n\n\nlet to_string ?buf ?(len = 256) ?std x =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n to_outbuf ?std ob x;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet to_channel ?buf ?len ?std oc x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_channel_writer ob\n\nlet to_output ?buf ?len ?std out x =\n let ob =\n match buf with\n None -> Bi_outbuf.create_output_writer ?len out\n | Some ob -> ob\n in\n to_outbuf ?std ob x;\n Bi_outbuf.flush_output_writer ob\n\nlet to_file ?len ?std file x =\n let oc = open_out file in\n try\n to_channel ?len ?std oc x;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\nlet stream_to_outbuf ?std ob st =\n Stream.iter (to_outbuf ?std ob) st\n\nlet stream_to_string ?buf ?(len = 256) ?std st =\n let ob =\n match buf with\n None -> Bi_outbuf.create len\n | Some ob ->\n Bi_outbuf.clear ob;\n ob\n in\n stream_to_outbuf ?std ob st;\n let s = Bi_outbuf.contents ob in\n Bi_outbuf.clear ob;\n s\n\nlet stream_to_channel ?buf ?len ?std oc st =\n let ob =\n match buf with\n None -> Bi_outbuf.create_channel_writer ?len oc\n | Some ob -> ob\n in\n stream_to_outbuf ?std ob st;\n Bi_outbuf.flush_channel_writer ob\n\nlet stream_to_file ?len ?std file st =\n let oc = open_out file in\n try\n stream_to_channel ?len ?std oc st;\n close_out oc\n with e ->\n close_out_noerr oc;\n raise e\n\n\nlet rec sort = function\n | `Assoc l ->\n let l = List.rev (List.rev_map (fun (k, v) -> (k, sort v)) l) in\n `Assoc (List.stable_sort (fun (a, _) (b, _) -> String.compare a b) l)\n | `List l ->\n `List (List.rev (List.rev_map sort l))\n#ifdef TUPLE\n | `Tuple l ->\n `Tuple (List.rev (List.rev_map sort l))\n#endif\n#ifdef VARIANT\n | `Variant (k, Some v) as x ->\n let v' = sort v in\n if v == v' then x\n else\n `Variant (k, Some v')\n#endif\n | x -> x\n", "let version = STRINGIFY(VERSION)\n\nexception Json_error of string\n\nlet json_error s = raise (Json_error s)\n\nexception End_of_array\nexception End_of_object\nexception End_of_tuple\nexception End_of_input\n\ntype in_param = {\n string_buf : Buffer.t\n}\n\nlet create_in_param ?(len = 256) () = {\n string_buf = Buffer.create len\n}\n\n\nlet utf8_of_code buf x =\n let add = Bi_outbuf.add_char in\n\n (* Straight <= doesn't work with signed 31-bit ints *)\n let maxbits n x = x lsr n = 0 in\n\n if maxbits 7 x then\n (* 7 *)\n add buf (Char.chr x)\n else if maxbits 11 x then (\n (* 5 + 6 *)\n add buf (Char.chr (0b11000000 lor ((x lsr 6) land 0b00011111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)))\n )\n else if maxbits 16 x then (\n (* 4 + 6 + 6 *)\n add buf (Char.chr (0b11100000 lor ((x lsr 12) land 0b00001111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)))\n )\n else if maxbits 21 x then (\n (* 3 + 6 + 6 + 6 *)\n add buf (Char.chr (0b11110000 lor ((x lsr 18) land 0b00000111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 12) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)));\n )\n else if maxbits 26 x then (\n (* 2 + 6 + 6 + 6 + 6 *)\n add buf (Char.chr (0b11111000 lor ((x lsr 24) land 0b00000011)));\n add buf (Char.chr (0b10000000 lor ((x lsr 18) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 12) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)));\n )\n else (\n assert (maxbits 31 x);\n (* 1 + 6 + 6 + 6 + 6 + 6 *)\n add buf (Char.chr (0b11111100 lor ((x lsr 30) land 0b00000001)));\n add buf (Char.chr (0b10000000 lor ((x lsr 24) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 18) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 12) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor ((x lsr 6) land 0b00111111)));\n add buf (Char.chr (0b10000000 lor (x land 0b00111111)));\n )\n\nlet code_of_surrogate_pair i j =\n let high10 = i - 0xD800 in\n let low10 = j - 0xDC00 in\n 0x10000 + ((high10 lsl 10) lor low10)\n\nlet utf8_of_surrogate_pair buf i j =\n utf8_of_code buf (code_of_surrogate_pair i j)\n\nlet is_object_or_array x =\n match x with\n `List _\n | `Assoc _ -> true\n | _ -> false\n\n\ntype lexer_state = {\n buf : Bi_outbuf.t;\n (* Buffer used to accumulate substrings *)\n\n mutable lnum : int;\n (* Current line number (starting from 1) *)\n\n mutable bol : int;\n (* Absolute position of the first character of the current line\n (starting from 0) *)\n\n mutable fname : string option;\n (* Name describing the input file *)\n}\n\nmodule Lexer_state =\nstruct\n type t = lexer_state = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\nend\n\nlet init_lexer ?buf ?fname ?(lnum = 1) () =\n let buf =\n match buf with\n\u0009None -> Bi_outbuf.create 256\n | Some buf -> buf\n in\n {\n buf = buf;\n lnum = lnum;\n bol = 0;\n fname = fname\n }\n", "{\n module Lexing =\n (*\n We override Lexing.engine in order to avoid creating a new position\n record each time a rule is matched.\n This reduces total parsing time by about 31%.\n *)\n struct\n include Lexing\n\n external c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\n\n let engine tbl state buf =\n let result = c_engine tbl state buf in\n (*\n if result >= 0 then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n *)\n result\n end\n\n open Printf\n open Lexing\n\n (* see description in common.mli *)\n type lexer_state = Lexer_state.t = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\n\n let dec c =\n Char.code c - 48\n\n let hex c =\n match c with\n '0'..'9' -> int_of_char c - int_of_char '0'\n | 'a'..'f' -> int_of_char c - int_of_char 'a' + 10\n | 'A'..'F' -> int_of_char c - int_of_char 'A' + 10\n | _ -> assert false\n\n let custom_error descr v lexbuf =\n let offs = lexbuf.lex_abs_pos - 1 in\n let bol = v.bol in\n let pos1 = offs + lexbuf.lex_start_pos - bol - 1 in\n let pos2 = max pos1 (offs + lexbuf.lex_curr_pos - bol) in\n let file_line =\n match v.fname with\n None -> \"Line\"\n | Some s ->\n sprintf \"File %s, line\" s\n in\n let bytes =\n if pos1 = pos2 then\n sprintf \"byte %i\" (pos1+1)\n else\n sprintf \"bytes %i-%i\" (pos1+1) (pos2+1)\n in\n let msg = sprintf \"%s %i, %s:\\n%s\" file_line v.lnum bytes descr in\n json_error msg\n\n\n let lexer_error descr v lexbuf =\n custom_error\n (sprintf \"%s '%s'\" descr (Lexing.lexeme lexbuf))\n v lexbuf\n\n let read_junk = ref (fun _ -> assert false)\n\n let long_error descr v lexbuf =\n let junk = Lexing.lexeme lexbuf in\n let extra_junk = !read_junk lexbuf in\n custom_error\n (sprintf \"%s '%s%s'\" descr junk extra_junk)\n v lexbuf\n\n let min10 = min_int / 10 - (if min_int mod 10 = 0 then 0 else 1)\n let max10 = max_int / 10 + (if max_int mod 10 = 0 then 0 else 1)\n\n exception Int_overflow\n\n let extract_positive_int lexbuf =\n let start = lexbuf.lex_start_pos in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n >= max10 then\n raise Int_overflow\n else\n n := 10 * !n + dec s.[i]\n done;\n if !n < 0 then\n raise Int_overflow\n else\n !n\n\n let make_positive_int v lexbuf =\n #ifdef INT\n try `Int (extract_positive_int lexbuf)\n with Int_overflow ->\n #endif\n #ifdef INTLIT\n `Intlit (lexeme lexbuf)\n #else\n lexer_error \"Int overflow\" v lexbuf\n #endif\n\n let extract_negative_int lexbuf =\n let start = lexbuf.lex_start_pos + 1 in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n <= min10 then\n raise Int_overflow\n else\n n := 10 * !n - dec s.[i]\n done;\n if !n > 0 then\n raise Int_overflow\n else\n !n\n\n let make_negative_int v lexbuf =\n #ifdef INT\n try `Int (extract_negative_int lexbuf)\n with Int_overflow ->\n #endif\n #ifdef INTLIT\n `Intlit (lexeme lexbuf)\n #else\n lexer_error \"Int overflow\" v lexbuf\n #endif\n\n\n let set_file_name v fname =\n v.fname <- fname\n\n let newline v lexbuf =\n v.lnum <- v.lnum + 1;\n v.bol <- lexbuf.lex_abs_pos + lexbuf.lex_curr_pos\n\n let add_lexeme buf lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bi_outbuf.add_substring buf lexbuf.lex_buffer lexbuf.lex_start_pos len\n\n let map_lexeme f lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n f lexbuf.lex_buffer lexbuf.lex_start_pos len\n\n type variant_kind = [ `Edgy_bracket | `Square_bracket | `Double_quote ]\n type tuple_kind = [ `Parenthesis | `Square_bracket ]\n}\n\nlet space = [' ' '\\t' '\\r']+\n\nlet digit = ['0'-'9']\nlet nonzero = ['1'-'9']\nlet digits = digit+\nlet frac = '.' digits\nlet e = ['e' 'E']['+' '-']?\nlet exp = e digits\n\nlet positive_int = (digit | nonzero digits)\nlet float = '-'? positive_int (frac | exp | frac exp)\nlet number = '-'? positive_int (frac | exp | frac exp)?\n\nlet hex = [ '0'-'9' 'a'-'f' 'A'-'F' ]\n\nlet ident = ['a'-'z' 'A'-'Z' '_']['a'-'z' 'A'-'Z' '_' '0'-'9']*\n\nlet optjunk4 = (eof | _ (eof | _ (eof | _ (eof | _))))\nlet optjunk8 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk4)))))\nlet optjunk12 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk8)))))\nlet optjunk16 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk12)))))\nlet optjunk20 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk16)))))\nlet optjunk24 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk20)))))\nlet optjunk28 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk24)))))\nlet optjunk32 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk28)))))\nlet junk = _ optjunk32\n\nrule read_json v = parse\n | \"true\" { `Bool true }\n | \"false\" { `Bool false }\n | \"null\" { `Null }\n | \"NaN\" {\n #ifdef FLOAT\n `Float nan\n #elif defined FLOATLIT\n `Floatlit \"NaN\"\n #endif\n }\n | \"Infinity\" {\n #ifdef FLOAT\n `Float infinity\n #elif defined FLOATLIT\n `Floatlit \"Infinity\"\n #endif\n }\n | \"-Infinity\" {\n #ifdef FLOAT\n `Float neg_infinity\n #elif defined FLOATLIT\n `Floatlit \"-Infinity\"\n #endif\n }\n | '\"' {\n #ifdef STRING\n Bi_outbuf.clear v.buf;\n `String (finish_string v lexbuf)\n #elif defined STRINGLIT\n `Stringlit (finish_stringlit v lexbuf)\n #endif\n }\n | positive_int { make_positive_int v lexbuf }\n | '-' positive_int { make_negative_int v lexbuf }\n | float {\n #ifdef FLOAT\n `Float (float_of_string (lexeme lexbuf))\n #elif defined FLOATLIT\n `Floatlit (lexeme lexbuf)\n #endif\n }\n\n | '{' { let acc = ref [] in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n done;\n assert false\n with End_of_object ->\n `Assoc (List.rev !acc)\n }\n\n | '[' { let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n `List (List.rev !acc)\n }\n\n | '(' {\n #ifdef TUPLE\n let acc = ref [] in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_tuple ->\n `Tuple (List.rev !acc)\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | '<' {\n #ifdef VARIANT\n read_space v lexbuf;\n let cons = read_ident v lexbuf in\n read_space v lexbuf;\n `Variant (cons, finish_variant v lexbuf)\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | \"//\"[^'\\n']* { read_json v lexbuf }\n | \"/*\" { finish_comment v lexbuf; read_json v lexbuf }\n | \"\\n\" { newline v lexbuf; read_json v lexbuf }\n | space { read_json v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n | _ { long_error \"Invalid token\" v lexbuf }\n\n\nand finish_string v = parse\n '\"' { Bi_outbuf.contents v.buf }\n | '\\\\' { finish_escaped_char v lexbuf;\n finish_string v lexbuf }\n | [^ '\"' '\\\\']+ { add_lexeme v.buf lexbuf;\n finish_string v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand map_string v f = parse\n '\"' { let b = v.buf in\n f b.Bi_outbuf.o_s 0 b.Bi_outbuf.o_len }\n | '\\\\' { finish_escaped_char v lexbuf;\n map_string v f lexbuf }\n | [^ '\"' '\\\\']+ { add_lexeme v.buf lexbuf;\n map_string v f lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_escaped_char v = parse\n '\"'\n | '\\\\'\n | '/' as c { Bi_outbuf.add_char v.buf c }\n | 'b' { Bi_outbuf.add_char v.buf '\\b' }\n | 'f' { Bi_outbuf.add_char v.buf '\\012' }\n | 'n' { Bi_outbuf.add_char v.buf '\\n' }\n | 'r' { Bi_outbuf.add_char v.buf '\\r' }\n | 't' { Bi_outbuf.add_char v.buf '\\t' }\n | 'u' (hex as a) (hex as b) (hex as c) (hex as d)\n { let x =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if x >= 0xD800 && x <= 0xDBFF then\n finish_surrogate_pair v x lexbuf\n else\n utf8_of_code v.buf x\n }\n | _ { long_error \"Invalid escape sequence\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_surrogate_pair v x = parse\n | \"\\\\u\" (hex as a) (hex as b) (hex as c) (hex as d)\n { let y =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if y >= 0xDC00 && y <= 0xDFFF then\n utf8_of_surrogate_pair v.buf x y\n else\n long_error \"Invalid low surrogate for code point beyond U+FFFF\"\n v lexbuf\n }\n | _ { long_error \"Missing escape sequence representing low surrogate \\\n for code point beyond U+FFFF\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_stringlit v = parse\n ( '\\\\' (['\"' '\\\\' '/' 'b' 'f' 'n' 'r' 't'] | 'u' hex hex hex hex)\n | [^'\"' '\\\\'] )* '\"'\n { let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n let s = String.create (len+1) in\n s.[0] <- '\"';\n String.blit lexbuf.lex_buffer lexbuf.lex_start_pos s 1 len;\n s\n }\n | _ { long_error \"Invalid string literal\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_variant v = parse\n ':' { let x = read_json v lexbuf in\n read_space v lexbuf;\n read_gt v lexbuf;\n Some x }\n | '>' { None }\n | _ { long_error \"Expected ':' or '>' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_lt v = parse\n '<' { () }\n | _ { long_error \"Expected '<' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_gt v = parse\n '>' { () }\n | _ { long_error \"Expected '>' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_comma v = parse\n ',' { () }\n | _ { long_error \"Expected ',' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand start_any_variant v = parse\n '<' { `Edgy_bracket }\n | '\"' { Bi_outbuf.clear v.buf;\n `Double_quote }\n | '[' { `Square_bracket }\n | _ { long_error \"Expected '<', '\\\"' or '[' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_comment v = parse\n | \"*/\" { () }\n | eof { long_error \"Unterminated comment\" v lexbuf }\n | '\\n' { newline v lexbuf; finish_comment v lexbuf }\n | _ { finish_comment v lexbuf }\n\n\n\n\n(* Readers expecting a particular JSON construct *)\n\nand read_eof = parse\n eof { true }\n | \"\" { false }\n\nand read_space v = parse\n | \"//\"[^'\\n']* ('\\n'|eof) { newline v lexbuf; read_space v lexbuf }\n | \"/*\" { finish_comment v lexbuf; read_space v lexbuf }\n | '\\n' { newline v lexbuf; read_space v lexbuf }\n | [' ' '\\t' '\\r']+ { read_space v lexbuf }\n | \"\" { () }\n\nand read_null v = parse\n \"null\" { () }\n | _ { long_error \"Expected 'null' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_null_if_possible v = parse\n \"null\" { true }\n | \"\" { false }\n\nand read_bool v = parse\n \"true\" { true }\n | \"false\" { false }\n\n (* tolerate booleans passed as strings without \\u obfuscation *)\n | \"\\\"true\\\"\" { true }\n | \"\\\"false\\\"\" { false }\n\n | _ { long_error \"Expected 'true' or 'false' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_int v = parse\n positive_int { try extract_positive_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf }\n | '-' positive_int { try extract_negative_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf }\n | '\"' { (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n int_of_string s\n with _ ->\n custom_error\n \"Expected an integer but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n }\n | _ { long_error \"Expected integer but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_int32 v = parse\n '-'? positive_int { try Int32.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf }\n | '\"' { (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int32.of_string s\n with _ ->\n custom_error\n \"Expected an int32 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n }\n | _ { long_error \"Expected int32 but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_int64 v = parse\n '-'? positive_int { try Int64.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf }\n | '\"' { (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int64.of_string s\n with _ ->\n custom_error\n \"Expected an int64 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n }\n | _ { long_error \"Expected int64 but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_number v = parse\n | \"NaN\" { nan }\n | \"Infinity\" { infinity }\n | \"-Infinity\" { neg_infinity }\n | number { float_of_string (lexeme lexbuf) }\n | '\"' { Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant float will pass,\n including hexadecimal and octal notations,\n and embedded underscores. *)\n float_of_string s\n with _ ->\n match s with\n \"NaN\" -> nan\n | \"Infinity\" -> infinity\n | \"-Infinity\" -> neg_infinity\n | _ ->\n custom_error\n \"Expected a number but found a string that \\\n doesn't even represent a number\"\n v lexbuf\n }\n | _ { long_error \"Expected number but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_string v = parse\n '\"' { Bi_outbuf.clear v.buf;\n finish_string v lexbuf }\n | _ { long_error \"Expected '\\\"' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_ident v = parse\n '\"' { Bi_outbuf.clear v.buf;\n finish_string v lexbuf }\n | ident as s\n { s }\n | _ { long_error \"Expected string or identifier but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand map_ident v f = parse\n '\"' { Bi_outbuf.clear v.buf;\n map_string v f lexbuf }\n | ident\n { map_lexeme f lexbuf }\n | _ { long_error \"Expected string or identifier but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_sequence read_cell init_acc v = parse\n '[' { let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell !acc v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !acc v lexbuf;\n done;\n assert false\n with End_of_array ->\n !acc\n }\n | _ { long_error \"Expected '[' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_list_rev read_cell v = parse\n '[' { let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n !acc\n }\n | _ { long_error \"Expected '[' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_array_end = parse\n ']' { raise End_of_array }\n | \"\" { () }\n\nand read_array_sep v = parse\n ',' { () }\n | ']' { raise End_of_array }\n | _ { long_error \"Expected ',' or ']' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\n\nand read_tuple read_cell init_acc v = parse\n '(' {\n #ifdef TUPLE\n let pos = ref 0 in\n let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n done;\n assert false\n with End_of_tuple ->\n !acc\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n | _ { long_error \"Expected ')' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_tuple_end = parse\n ')' { raise End_of_tuple }\n | \"\" { () }\n\nand read_tuple_end2 v std = parse\n ')' { if std then\n long_error \"Expected ')' or '' but found\" v lexbuf\n else\n raise End_of_tuple }\n | ']' { if std then\n raise End_of_tuple\n else\n long_error \"Expected ']' or '' but found\" v lexbuf }\n | \"\" { () }\n\nand read_tuple_sep v = parse\n ',' { () }\n | ')' { raise End_of_tuple }\n | _ { long_error \"Expected ',' or ')' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_tuple_sep2 v std = parse\n ',' { () }\n | ')' { if std then\n long_error \"Expected ',' or ']' but found\" v lexbuf\n else\n raise End_of_tuple }\n | ']' { if std then\n raise End_of_tuple\n else\n long_error \"Expected ',' or ')' but found\" v lexbuf }\n | _ { long_error \"Expected ',' or ')' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\n(* Read a JSON object, reading the keys using a custom parser *)\nand read_abstract_fields read_key read_field init_acc v = parse\n '{' { let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n done;\n assert false\n with End_of_object ->\n !acc\n }\n | _ { long_error \"Expected '{' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_lcurl v = parse\n '{' { () }\n | _ { long_error \"Expected '{' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_object_end = parse\n '}' { raise End_of_object }\n | \"\" { () }\n\nand read_object_sep v = parse\n ',' { () }\n | '}' { raise End_of_object }\n | _ { long_error \"Expected ',' or '}' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_colon v = parse\n ':' { () }\n | _ { long_error \"Expected ':' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand start_any_tuple v = parse\n '(' { false }\n | '[' { true }\n | _ { long_error \"Expected '(' or '[' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_lpar v = parse\n '(' { () }\n | _ { long_error \"Expected '(' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_rpar v = parse\n ')' { () }\n | _ { long_error \"Expected ')' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_lbr v = parse\n '[' { () }\n | _ { long_error \"Expected '[' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_rbr v = parse\n ']' { () }\n | _ { long_error \"Expected ']' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\n(*** And now pretty much the same thing repeated,\n only for the purpose of skipping ignored field values ***)\n\nand skip_json v = parse\n | \"true\" { () }\n | \"false\" { () }\n | \"null\" { () }\n | \"NaN\" { () }\n | \"Infinity\" { () }\n | \"-Infinity\" { () }\n | '\"' { finish_skip_stringlit v lexbuf }\n | '-'? positive_int { () }\n | float { () }\n\n | '{' { try\n read_space v lexbuf;\n read_object_end lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n }\n\n | '[' { try\n read_space v lexbuf;\n read_array_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n }\n\n | '(' {\n #ifdef TUPLE\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | '<' {\n #ifdef VARIANT\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n finish_skip_variant v lexbuf\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | \"//\"[^'\\n']* { skip_json v lexbuf }\n | \"/*\" { finish_comment v lexbuf; skip_json v lexbuf }\n | \"\\n\" { newline v lexbuf; skip_json v lexbuf }\n | space { skip_json v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n | _ { long_error \"Invalid token\" v lexbuf }\n\n\nand finish_skip_stringlit v = parse\n ( '\\\\' (['\"' '\\\\' '/' 'b' 'f' 'n' 'r' 't'] | 'u' hex hex hex hex)\n | [^'\"' '\\\\'] )* '\"'\n { () }\n | _ { long_error \"Invalid string literal\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_skip_variant v = parse\n ':' { skip_json v lexbuf;\n read_space v lexbuf;\n read_gt v lexbuf }\n | '>' { () }\n | _ { long_error \"Expected ':' or '>' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand skip_ident v = parse\n '\"' { finish_skip_stringlit v lexbuf }\n | ident { () }\n | _ { long_error \"Expected string or identifier but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\n(*** And now pretty much the same thing repeated,\n only for the purpose of buffering deferred field values ***)\n\nand buffer_json v = parse\n | \"true\"\n | \"false\"\n | \"null\"\n | \"NaN\"\n | \"Infinity\"\n | \"-Infinity\"\n | '-'? positive_int\n | float { add_lexeme v.buf lexbuf }\n\n | '\"' { finish_buffer_stringlit v lexbuf }\n | '{' { try\n Bi_outbuf.add_char v.buf '{';\n buffer_space v lexbuf;\n buffer_object_end v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_object_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n }\n\n | '[' { try\n Bi_outbuf.add_char v.buf '[';\n buffer_space v lexbuf;\n buffer_array_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_array_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n }\n\n | '(' {\n #ifdef TUPLE\n try\n Bi_outbuf.add_char v.buf '(';\n buffer_space v lexbuf;\n buffer_tuple_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_tuple_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | '<' {\n #ifdef VARIANT\n Bi_outbuf.add_char v.buf '<';\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n finish_buffer_variant v lexbuf\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | \"//\"[^'\\n']* { add_lexeme v.buf lexbuf; buffer_json v lexbuf }\n | \"/*\" { Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_json v lexbuf }\n | \"\\n\" { Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_json v lexbuf }\n | space { add_lexeme v.buf lexbuf; buffer_json v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n | _ { long_error \"Invalid token\" v lexbuf }\n\n\nand finish_buffer_stringlit v = parse\n ( '\\\\' (['\"' '\\\\' '/' 'b' 'f' 'n' 'r' 't'] | 'u' hex hex hex hex)\n | [^'\"' '\\\\'] )* '\"'\n { Bi_outbuf.add_char v.buf '\"';\n add_lexeme v.buf lexbuf\n }\n | _ { long_error \"Invalid string literal\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_buffer_variant v = parse\n ':' { Bi_outbuf.add_char v.buf ':';\n buffer_json v lexbuf;\n buffer_space v lexbuf;\n buffer_gt v lexbuf }\n | '>' { Bi_outbuf.add_char v.buf '>' }\n | _ { long_error \"Expected ':' or '>' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_ident v = parse\n '\"' { finish_buffer_stringlit v lexbuf }\n | ident { add_lexeme v.buf lexbuf }\n | _ { long_error \"Expected string or identifier but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_space v = parse\n | \"//\"[^'\\n']* ('\\n'|eof) {\n add_lexeme v.buf lexbuf;\n newline v lexbuf;\n buffer_space v lexbuf }\n | \"/*\" {\n Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_space v lexbuf }\n | '\\n' {\n Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_space v lexbuf }\n | [' ' '\\t' '\\r']+ {\n add_lexeme v.buf lexbuf;\n buffer_space v lexbuf }\n | \"\" { () }\n\nand buffer_object_end v = parse\n '}' {\n Bi_outbuf.add_char v.buf '}';\n raise End_of_object }\n | \"\" { () }\n\nand buffer_object_sep v = parse\n ',' { Bi_outbuf.add_char v.buf ',' }\n | '}' { Bi_outbuf.add_char v.buf '}'; raise End_of_object }\n | _ { long_error \"Expected ',' or '}' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_array_end v = parse\n ']' { Bi_outbuf.add_char v.buf ']'; raise End_of_array }\n | \"\" { () }\n\nand buffer_array_sep v = parse\n ',' { Bi_outbuf.add_char v.buf ',' }\n | ']' { Bi_outbuf.add_char v.buf ']'; raise End_of_array }\n | _ { long_error \"Expected ',' or ']' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_tuple_end v = parse\n ')' {\n Bi_outbuf.add_char v.buf ')';\n raise End_of_tuple }\n | \"\" { () }\n\nand buffer_tuple_sep v = parse\n ',' { Bi_outbuf.add_char v.buf ',' }\n | ')' { Bi_outbuf.add_char v.buf ')'; raise End_of_tuple }\n | _ { long_error \"Expected ',' or ')' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_colon v = parse\n ':' { Bi_outbuf.add_char v.buf ':' }\n | _ { long_error \"Expected ':' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_gt v = parse\n '>' { Bi_outbuf.add_char v.buf '>' }\n | _ { long_error \"Expected '>' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_buffer_comment v = parse\n | \"*/\" { Bi_outbuf.add_string v.buf \"*/\" }\n | eof { long_error \"Unterminated comment\" v lexbuf }\n | '\\n' { Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n finish_buffer_comment v lexbuf }\n | _ { add_lexeme v.buf lexbuf; finish_buffer_comment v lexbuf }\n\nand junk = parse\n junk { Lexing.lexeme lexbuf }\n\n{\n let _ = (read_json : lexer_state -> Lexing.lexbuf -> json)\n\n let () =\n read_junk := junk\n\n let read_int8 v lexbuf =\n let n = read_int v lexbuf in\n if n < 0 || n > 255 then\n lexer_error \"Int8 overflow\" v lexbuf\n else\n char_of_int n\n\n let read_list read_cell v lexbuf =\n List.rev (read_list_rev read_cell v lexbuf)\n\n let array_of_rev_list l =\n match l with\n [] -> [| |]\n | x :: tl ->\n let len = List.length l in\n let a = Array.make len x in\n let r = ref tl in\n for i = len - 2 downto 0 do\n a.(i) <- List.hd !r;\n r := List.tl !r\n done;\n a\n\n let read_array read_cell v lexbuf =\n let l = read_list_rev read_cell v lexbuf in\n array_of_rev_list l\n\n (* Read a JSON object, reading the keys into OCaml strings\n (provided for backward compatibility) *)\n let read_fields read_field init_acc v =\n read_abstract_fields read_ident read_field init_acc v\n\n let finish v lexbuf =\n read_space v lexbuf;\n if not (read_eof lexbuf) then\n long_error \"Junk after end of JSON value:\" v lexbuf\n\n let init_lexer = init_lexer\n\n let from_lexbuf v ?(stream = false) lexbuf =\n read_space v lexbuf;\n\n let x =\n if read_eof lexbuf then\n raise End_of_input\n else\n read_json v lexbuf\n in\n\n if not stream then\n finish v lexbuf;\n\n x\n\n\n let from_string ?buf ?fname ?lnum s =\n try\n let lexbuf = Lexing.from_string s in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_channel ?buf ?fname ?lnum ic =\n try\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n try\n let x = from_channel ?buf ?fname ?lnum ic in\n close_in ic;\n x\n with e ->\n close_in_noerr ic;\n raise e\n\n let stream_from_lexbuf v ?(fin = fun () -> ()) lexbuf =\n let stream = Some true in\n let f i =\n try Some (from_lexbuf v ?stream lexbuf)\n with\n End_of_input ->\n fin ();\n None\n | e ->\n (try fin () with _ -> ());\n raise e\n in\n Stream.from f\n\n let stream_from_string ?buf ?fname ?lnum s =\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v (Lexing.from_string s)\n\n let stream_from_channel ?buf ?fin ?fname ?lnum ic =\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ?fin lexbuf\n\n let stream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ~fin lexbuf\n\n type json_line = [ `Json of json | `Exn of exn ]\n\n let linestream_from_channel\n ?buf ?(fin = fun () -> ()) ?fname ?lnum:(lnum0 = 1) ic =\n let buf =\n match buf with\n None -> Some (Bi_outbuf.create 256)\n | Some _ -> buf\n in\n let f i =\n try\n let line = input_line ic in\n let lnum = lnum0 + i in\n Some (`Json (from_string ?buf ?fname ~lnum line))\n with\n End_of_file -> fin (); None\n | e -> Some (`Exn e)\n in\n Stream.from f\n\n let linestream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n linestream_from_channel ?buf ~fin ?fname ?lnum ic\n\n let prettify ?std s =\n pretty_to_string ?std (from_string s)\n\n let compact ?std s =\n to_string (from_string s)\n\n let validate_json _path _value = None\n}\n", "# 1 \"read.mll\"\n \n module Lexing =\n (*\n We override Lexing.engine in order to avoid creating a new position\n record each time a rule is matched.\n This reduces total parsing time by about 31%.\n *)\n struct\n include Lexing\n\n external c_engine : lex_tables -> int -> lexbuf -> int = \"caml_lex_engine\"\n\n let engine tbl state buf =\n let result = c_engine tbl state buf in\n (*\n if result >= 0 then begin\n buf.lex_start_p <- buf.lex_curr_p;\n buf.lex_curr_p <- {buf.lex_curr_p\n with pos_cnum = buf.lex_abs_pos + buf.lex_curr_pos};\n end;\n *)\n result\n end\n\n open Printf\n open Lexing\n\n (* see description in common.mli *)\n type lexer_state = Lexer_state.t = {\n buf : Bi_outbuf.t;\n mutable lnum : int;\n mutable bol : int;\n mutable fname : string option;\n }\n\n let dec c =\n Char.code c - 48\n\n let hex c =\n match c with\n '0'..'9' -> int_of_char c - int_of_char '0'\n | 'a'..'f' -> int_of_char c - int_of_char 'a' + 10\n | 'A'..'F' -> int_of_char c - int_of_char 'A' + 10\n | _ -> assert false\n\n let custom_error descr v lexbuf =\n let offs = lexbuf.lex_abs_pos - 1 in\n let bol = v.bol in\n let pos1 = offs + lexbuf.lex_start_pos - bol - 1 in\n let pos2 = max pos1 (offs + lexbuf.lex_curr_pos - bol) in\n let file_line =\n match v.fname with\n None -> \"Line\"\n | Some s ->\n sprintf \"File %s, line\" s\n in\n let bytes =\n if pos1 = pos2 then\n sprintf \"byte %i\" (pos1+1)\n else\n sprintf \"bytes %i-%i\" (pos1+1) (pos2+1)\n in\n let msg = sprintf \"%s %i, %s:\\n%s\" file_line v.lnum bytes descr in\n json_error msg\n\n\n let lexer_error descr v lexbuf =\n custom_error\n (sprintf \"%s '%s'\" descr (Lexing.lexeme lexbuf))\n v lexbuf\n\n let read_junk = ref (fun _ -> assert false)\n\n let long_error descr v lexbuf =\n let junk = Lexing.lexeme lexbuf in\n let extra_junk = !read_junk lexbuf in\n custom_error\n (sprintf \"%s '%s%s'\" descr junk extra_junk)\n v lexbuf\n\n let min10 = min_int / 10 - (if min_int mod 10 = 0 then 0 else 1)\n let max10 = max_int / 10 + (if max_int mod 10 = 0 then 0 else 1)\n\n exception Int_overflow\n\n let extract_positive_int lexbuf =\n let start = lexbuf.lex_start_pos in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n >= max10 then\n raise Int_overflow\n else\n n := 10 * !n + dec s.[i]\n done;\n if !n < 0 then\n raise Int_overflow\n else\n !n\n\n let make_positive_int v lexbuf =\n #ifdef INT\n try `Int (extract_positive_int lexbuf)\n with Int_overflow ->\n #endif\n #ifdef INTLIT\n `Intlit (lexeme lexbuf)\n #else\n lexer_error \"Int overflow\" v lexbuf\n #endif\n\n let extract_negative_int lexbuf =\n let start = lexbuf.lex_start_pos + 1 in\n let stop = lexbuf.lex_curr_pos in\n let s = lexbuf.lex_buffer in\n let n = ref 0 in\n for i = start to stop - 1 do\n if !n <= min10 then\n raise Int_overflow\n else\n n := 10 * !n - dec s.[i]\n done;\n if !n > 0 then\n raise Int_overflow\n else\n !n\n\n let make_negative_int v lexbuf =\n #ifdef INT\n try `Int (extract_negative_int lexbuf)\n with Int_overflow ->\n #endif\n #ifdef INTLIT\n `Intlit (lexeme lexbuf)\n #else\n lexer_error \"Int overflow\" v lexbuf\n #endif\n\n\n let set_file_name v fname =\n v.fname <- fname\n\n let newline v lexbuf =\n v.lnum <- v.lnum + 1;\n v.bol <- lexbuf.lex_abs_pos + lexbuf.lex_curr_pos\n\n let add_lexeme buf lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n Bi_outbuf.add_substring buf lexbuf.lex_buffer lexbuf.lex_start_pos len\n\n let map_lexeme f lexbuf =\n let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n f lexbuf.lex_buffer lexbuf.lex_start_pos len\n\n type variant_kind = [ `Edgy_bracket | `Square_bracket | `Double_quote ]\n type tuple_kind = [ `Parenthesis | `Square_bracket ]\n\n# 161 \"read.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base = \n \"\\000\\000\\236\\255\\237\\255\\003\\000\\239\\255\\016\\000\\242\\255\\243\\255\\\n \\244\\255\\245\\255\\000\\000\\031\\000\\249\\255\\085\\000\\001\\000\\000\\000\\\n \\000\\000\\001\\000\\000\\000\\001\\000\\002\\000\\255\\255\\000\\000\\000\\000\\\n \\003\\000\\254\\255\\001\\000\\004\\000\\253\\255\\011\\000\\252\\255\\003\\000\\\n \\001\\000\\003\\000\\002\\000\\003\\000\\000\\000\\251\\255\\021\\000\\097\\000\\\n \\010\\000\\022\\000\\020\\000\\016\\000\\022\\000\\012\\000\\008\\000\\250\\255\\\n \\119\\000\\129\\000\\139\\000\\161\\000\\171\\000\\181\\000\\193\\000\\209\\000\\\n \\240\\255\\011\\000\\038\\000\\252\\255\\065\\000\\254\\255\\255\\255\\110\\000\\\n \\252\\255\\163\\000\\254\\255\\255\\255\\234\\000\\247\\255\\248\\255\\048\\001\\\n \\250\\255\\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\071\\001\\126\\001\\\n \\149\\001\\249\\255\\039\\000\\253\\255\\254\\255\\038\\000\\187\\001\\210\\001\\\n \\248\\001\\015\\002\\255\\255\\220\\000\\253\\255\\255\\255\\245\\000\\039\\002\\\n \\109\\002\\014\\001\\088\\002\\164\\002\\187\\002\\225\\002\\013\\000\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\014\\000\\253\\255\\254\\255\\255\\255\\030\\000\\\n \\253\\255\\254\\255\\255\\255\\015\\000\\253\\255\\254\\255\\255\\255\\017\\001\\\n \\251\\255\\252\\255\\253\\255\\254\\255\\255\\255\\019\\000\\252\\255\\253\\255\\\n \\254\\255\\015\\000\\255\\255\\016\\000\\255\\255\\008\\001\\005\\000\\253\\255\\\n \\023\\000\\254\\255\\020\\000\\255\\255\\046\\000\\253\\255\\254\\255\\042\\000\\\n \\052\\000\\053\\000\\255\\255\\053\\000\\048\\000\\091\\000\\092\\000\\255\\255\\\n \\027\\001\\250\\255\\251\\255\\137\\000\\104\\000\\089\\000\\088\\000\\106\\000\\\n \\255\\255\\143\\000\\137\\000\\177\\000\\254\\255\\183\\000\\168\\000\\166\\000\\\n \\183\\000\\002\\000\\253\\255\\177\\000\\172\\000\\187\\000\\004\\000\\252\\255\\\n \\053\\002\\251\\255\\252\\255\\253\\255\\103\\001\\255\\255\\248\\002\\254\\255\\\n \\006\\003\\030\\003\\252\\255\\253\\255\\254\\255\\255\\255\\040\\003\\050\\003\\\n \\074\\003\\252\\255\\253\\255\\254\\255\\255\\255\\061\\003\\084\\003\\108\\003\\\n \\249\\255\\250\\255\\251\\255\\244\\000\\120\\003\\142\\003\\179\\000\\194\\000\\\n \\015\\000\\255\\255\\190\\000\\188\\000\\187\\000\\193\\000\\183\\000\\179\\000\\\n \\254\\255\\191\\000\\201\\000\\200\\000\\196\\000\\203\\000\\193\\000\\189\\000\\\n \\253\\255\\157\\003\\095\\003\\174\\003\\196\\003\\206\\003\\216\\003\\228\\003\\\n \\239\\003\\060\\000\\253\\255\\254\\255\\255\\255\\012\\004\\252\\255\\253\\255\\\n \\087\\004\\255\\255\\145\\004\\252\\255\\253\\255\\221\\004\\255\\255\\229\\000\\\n \\253\\255\\254\\255\\255\\255\\231\\000\\253\\255\\254\\255\\255\\255\\002\\000\\\n \\255\\255\\018\\001\\252\\255\\253\\255\\254\\255\\255\\255\\034\\001\\253\\255\\\n \\254\\255\\255\\255\\000\\000\\255\\255\\003\\000\\254\\255\\255\\255\\038\\001\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\120\\001\\251\\255\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\208\\000\\253\\255\\254\\255\\255\\255\\211\\000\\253\\255\\\n \\254\\255\\255\\255\\189\\000\\255\\255\\143\\001\\252\\255\\253\\255\\254\\255\\\n \\255\\255\\013\\001\\253\\255\\254\\255\\255\\255\\095\\001\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\050\\001\\253\\255\\254\\255\\255\\255\\026\\001\\253\\255\\\n \\254\\255\\255\\255\\233\\000\\253\\255\\254\\255\\255\\255\\222\\000\\253\\255\\\n \\254\\255\\255\\255\\079\\005\\237\\255\\238\\255\\010\\000\\240\\255\\044\\001\\\n \\243\\255\\244\\255\\245\\255\\246\\255\\061\\001\\002\\004\\249\\255\\045\\005\\\n \\209\\000\\228\\000\\211\\000\\232\\000\\225\\000\\223\\000\\240\\000\\255\\255\\\n \\235\\000\\234\\000\\008\\001\\254\\255\\004\\001\\023\\001\\253\\255\\054\\001\\\n \\252\\255\\031\\001\\029\\001\\032\\001\\039\\001\\049\\001\\045\\001\\251\\255\\\n \\057\\001\\082\\001\\080\\001\\078\\001\\084\\001\\074\\001\\086\\001\\250\\255\\\n \\110\\005\\012\\004\\123\\005\\155\\005\\165\\005\\177\\005\\187\\005\\197\\005\\\n \\241\\255\\199\\001\\077\\002\\253\\255\\255\\255\\154\\002\\222\\005\\209\\005\\\n \\155\\002\\239\\005\\053\\006\\076\\006\\114\\006\\016\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\152\\006\\252\\255\\253\\255\\227\\006\\255\\255\\085\\007\\\n \\244\\255\\245\\255\\011\\000\\247\\255\\076\\002\\250\\255\\251\\255\\252\\255\\\n \\253\\255\\254\\255\\031\\002\\243\\005\\051\\007\\100\\001\\115\\001\\104\\001\\\n \\133\\001\\118\\001\\154\\001\\171\\001\\255\\255\\173\\001\\176\\001\\191\\001\\\n \\185\\001\\187\\001\\253\\001\\230\\001\\230\\001\\234\\001\\247\\001\\237\\001\\\n \\234\\001\\009\\002\\019\\002\\019\\002\\015\\002\\021\\002\\011\\002\\007\\002\\\n \\142\\006\\152\\006\\116\\007\\170\\007\\180\\007\\190\\007\\200\\007\\210\\007\\\n \\248\\255\\120\\002\\167\\002\\253\\255\\255\\255\\216\\002\\082\\007\\220\\007\\\n \\236\\002\\244\\007\\058\\008\\081\\008\\119\\008\\076\\002\\252\\255\\253\\255\\\n \\254\\255\\255\\255\\157\\008\\252\\255\\253\\255\\232\\008\\255\\255\\135\\002\\\n \\120\\002\\253\\255\\100\\002\\254\\255\\182\\002\\255\\255\\011\\002\\255\\255\\\n \\204\\002\\252\\255\\253\\255\\254\\255\\255\\255\\046\\002\\255\\255\\178\\002\\\n \\252\\255\\253\\255\\254\\255\\255\\255\\023\\000\\255\\255\\183\\002\\252\\255\\\n \\253\\255\\254\\255\\255\\255\\187\\002\\253\\255\\254\\255\\255\\255\\121\\002\\\n \\253\\255\\254\\255\\255\\255\\184\\002\\252\\255\\253\\255\\254\\255\\019\\000\\\n \\255\\255\\140\\001\\146\\001\\150\\001\\255\\255\\151\\001\\154\\001\\168\\001\\\n \\170\\001\\171\\001\\172\\001\\173\\001\\181\\001\\184\\001\\185\\001\\187\\001\\\n \\191\\001\\193\\001\\195\\001\\196\\001\\197\\001\\200\\001\\203\\001\\223\\001\\\n \\225\\001\\228\\001\\249\\001\\251\\001\\002\\002\\004\\002\\011\\002\\012\\002\\\n \\013\\002\\027\\002\\000\\000\";\n Lexing.lex_backtrk = \n \"\\255\\255\\255\\255\\255\\255\\017\\000\\255\\255\\019\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\019\\000\\019\\000\\019\\000\\\n \\019\\000\\019\\000\\019\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\008\\000\\008\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\009\\000\\255\\255\\\n \\255\\255\\014\\000\\255\\255\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\003\\000\\255\\255\\001\\000\\255\\255\\004\\000\\003\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\004\\000\\004\\000\\004\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\000\\000\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\002\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\003\\000\\005\\000\\005\\000\\005\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\003\\000\\255\\255\\003\\000\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\002\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\016\\000\\255\\255\\018\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\007\\000\\007\\000\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\018\\000\\018\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\008\\000\\255\\255\\\n \\255\\255\\013\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\009\\000\\255\\255\\011\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\000\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\006\\000\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\004\\000\\\n \\003\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\003\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\";\n Lexing.lex_default = \n \"\\001\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\057\\000\\060\\000\\000\\000\\060\\000\\000\\000\\000\\000\\065\\000\\\n \\000\\000\\065\\000\\000\\000\\000\\000\\070\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\084\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\094\\000\\000\\000\\000\\000\\097\\000\\255\\255\\\n \\255\\255\\097\\000\\255\\255\\255\\255\\255\\255\\255\\255\\104\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\109\\000\\000\\000\\000\\000\\000\\000\\113\\000\\\n \\000\\000\\000\\000\\000\\000\\117\\000\\000\\000\\000\\000\\000\\000\\121\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\126\\000\\000\\000\\000\\000\\\n \\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\138\\000\\000\\000\\142\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\154\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\178\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\187\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\194\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\201\\000\\\n \\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\235\\000\\000\\000\\000\\000\\000\\000\\239\\000\\000\\000\\000\\000\\\n \\255\\255\\000\\000\\244\\000\\000\\000\\000\\000\\255\\255\\000\\000\\249\\000\\\n \\000\\000\\000\\000\\000\\000\\253\\000\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\003\\001\\000\\000\\000\\000\\000\\000\\000\\000\\008\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\017\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\022\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\028\\001\\000\\000\\000\\000\\000\\000\\032\\001\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\038\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\043\\001\\000\\000\\000\\000\\000\\000\\047\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\052\\001\\000\\000\\000\\000\\000\\000\\056\\001\\000\\000\\\n \\000\\000\\000\\000\\060\\001\\000\\000\\000\\000\\000\\000\\064\\001\\000\\000\\\n \\000\\000\\000\\000\\067\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\121\\001\\125\\001\\000\\000\\000\\000\\128\\001\\255\\255\\255\\255\\\n \\128\\001\\255\\255\\255\\255\\255\\255\\255\\255\\135\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\140\\001\\000\\000\\000\\000\\255\\255\\000\\000\\144\\001\\\n \\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\193\\001\\197\\001\\000\\000\\000\\000\\200\\001\\255\\255\\255\\255\\\n \\200\\001\\255\\255\\255\\255\\255\\255\\255\\255\\207\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\212\\001\\000\\000\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\000\\000\\220\\001\\000\\000\\255\\255\\000\\000\\\n \\226\\001\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\233\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\240\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\245\\001\\000\\000\\000\\000\\000\\000\\249\\001\\\n \\000\\000\\000\\000\\000\\000\\252\\001\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\000\\000\\002\\002\\003\\002\\005\\002\\000\\000\\006\\002\\007\\002\\008\\002\\\n \\009\\002\\010\\002\\011\\002\\012\\002\\013\\002\\014\\002\\015\\002\\016\\002\\\n \\017\\002\\018\\002\\019\\002\\020\\002\\021\\002\\022\\002\\023\\002\\024\\002\\\n \\025\\002\\026\\002\\027\\002\\028\\002\\029\\002\\030\\002\\031\\002\\032\\002\\\n \\033\\002\\034\\002\\004\\002\";\n Lexing.lex_trans = \n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\003\\000\\004\\000\\000\\000\\003\\000\\003\\000\\134\\000\\000\\000\\\n \\003\\000\\000\\000\\134\\000\\069\\001\\146\\001\\255\\255\\000\\000\\069\\001\\\n \\146\\001\\000\\000\\000\\000\\000\\000\\000\\000\\127\\000\\139\\000\\000\\000\\\n \\003\\000\\000\\000\\012\\000\\003\\000\\170\\000\\134\\000\\175\\000\\000\\000\\\n \\007\\000\\011\\001\\069\\001\\146\\001\\014\\001\\013\\000\\049\\000\\005\\000\\\n \\010\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\011\\000\\056\\000\\118\\000\\006\\000\\129\\000\\130\\000\\057\\000\\\n \\237\\001\\137\\000\\000\\002\\049\\000\\000\\000\\048\\000\\138\\000\\106\\000\\\n \\062\\000\\014\\000\\110\\000\\105\\000\\000\\000\\049\\000\\015\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\030\\000\\048\\000\\008\\000\\114\\000\\209\\000\\236\\000\\000\\001\\\n \\013\\001\\029\\000\\022\\000\\255\\255\\048\\000\\048\\000\\017\\000\\021\\000\\\n \\025\\000\\032\\000\\033\\000\\035\\000\\023\\000\\027\\000\\016\\000\\031\\000\\\n \\028\\000\\034\\000\\019\\000\\024\\000\\018\\000\\026\\000\\020\\000\\036\\000\\\n \\041\\000\\037\\000\\048\\000\\009\\000\\042\\000\\043\\000\\044\\000\\045\\000\\\n \\046\\000\\047\\000\\061\\000\\085\\000\\048\\000\\038\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\049\\000\\\n \\067\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\086\\000\\143\\000\\255\\255\\040\\000\\144\\000\\\n \\145\\000\\146\\000\\055\\000\\148\\000\\055\\000\\149\\000\\048\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\255\\255\\048\\000\\150\\000\\\n \\151\\000\\161\\000\\066\\000\\158\\000\\053\\000\\159\\000\\053\\000\\160\\000\\\n \\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\165\\000\\\n \\051\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\162\\000\\163\\000\\166\\000\\093\\000\\255\\255\\\n \\002\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\255\\255\\077\\000\\103\\000\\108\\000\\116\\000\\\n \\132\\000\\134\\000\\135\\000\\128\\000\\139\\000\\134\\000\\164\\000\\093\\000\\\n \\171\\000\\077\\000\\167\\000\\168\\000\\169\\000\\172\\000\\112\\000\\173\\000\\\n \\174\\000\\210\\000\\226\\000\\208\\000\\211\\000\\212\\000\\059\\000\\083\\000\\\n \\134\\000\\213\\000\\214\\000\\215\\000\\216\\000\\218\\000\\141\\000\\219\\000\\\n \\093\\000\\220\\000\\221\\000\\123\\000\\222\\000\\223\\000\\224\\000\\136\\000\\\n \\095\\000\\225\\000\\035\\001\\065\\001\\234\\000\\155\\000\\005\\001\\097\\001\\\n \\250\\000\\255\\255\\254\\000\\057\\001\\061\\001\\095\\001\\077\\000\\044\\001\\\n \\092\\001\\088\\001\\009\\001\\029\\001\\076\\000\\124\\000\\033\\001\\018\\001\\\n \\075\\000\\098\\000\\019\\001\\085\\001\\086\\001\\087\\001\\120\\001\\089\\001\\\n \\074\\000\\225\\000\\053\\001\\121\\001\\073\\000\\090\\001\\072\\000\\071\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\098\\000\\113\\001\\122\\000\\091\\001\\064\\000\\004\\001\\\n \\093\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\156\\000\\112\\001\\094\\001\\096\\001\\098\\001\\099\\001\\049\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\100\\001\\157\\000\\\n \\101\\001\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\183\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\024\\001\\112\\001\\255\\255\\025\\001\\102\\001\\103\\001\\105\\001\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\106\\001\\107\\001\\048\\001\\040\\001\\108\\001\\109\\001\\110\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\111\\001\\\n \\027\\001\\255\\255\\171\\001\\031\\001\\170\\001\\023\\001\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\092\\000\\168\\001\\063\\001\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\248\\000\\165\\001\\252\\000\\\n \\162\\001\\059\\001\\069\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\255\\255\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\039\\001\\042\\001\\255\\255\\163\\001\\\n \\164\\001\\120\\000\\002\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\166\\001\\055\\001\\153\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\007\\001\\167\\001\\164\\001\\169\\001\\016\\001\\164\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\051\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\090\\000\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\\n \\090\\000\\097\\000\\137\\001\\164\\001\\172\\001\\185\\001\\136\\001\\173\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\097\\000\\179\\000\\\n \\174\\001\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\046\\001\\\n \\175\\001\\176\\001\\180\\000\\164\\001\\184\\001\\181\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\124\\001\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\192\\001\\178\\001\\\n \\021\\001\\179\\001\\097\\000\\193\\001\\180\\001\\181\\001\\182\\001\\183\\001\\\n \\164\\001\\216\\001\\255\\255\\097\\000\\184\\001\\216\\001\\209\\001\\097\\000\\\n \\223\\001\\097\\000\\208\\001\\230\\001\\255\\255\\097\\000\\219\\001\\037\\001\\\n \\216\\001\\217\\001\\004\\002\\220\\001\\216\\001\\097\\000\\004\\002\\004\\002\\\n \\216\\001\\097\\000\\004\\002\\097\\000\\096\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\216\\001\\\n \\004\\002\\126\\001\\004\\002\\004\\002\\004\\002\\004\\002\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\097\\000\\004\\002\\218\\001\\250\\001\\\n \\004\\002\\004\\002\\097\\000\\004\\002\\124\\001\\124\\001\\097\\000\\004\\002\\\n \\221\\001\\004\\002\\253\\001\\004\\002\\004\\002\\004\\002\\097\\000\\255\\255\\\n \\004\\002\\196\\001\\097\\000\\004\\002\\097\\000\\096\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\235\\001\\004\\002\\\n \\241\\001\\004\\002\\255\\001\\242\\001\\004\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\246\\001\\129\\001\\129\\001\\\n \\228\\001\\004\\002\\196\\001\\004\\002\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\004\\002\\198\\001\\004\\002\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\004\\002\\004\\002\\004\\002\\196\\001\\234\\001\\\n \\134\\001\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\097\\000\\097\\000\\097\\000\\004\\002\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\000\\000\\000\\000\\201\\001\\177\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\188\\000\\000\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\201\\001\\227\\001\\000\\000\\191\\000\\206\\001\\123\\001\\189\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\189\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\195\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\198\\000\\\n \\255\\255\\248\\001\\196\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\196\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\202\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\227\\000\\205\\000\\255\\255\\255\\255\\203\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\226\\000\\195\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\232\\001\\000\\000\\000\\000\\206\\000\\221\\001\\239\\001\\\n \\254\\001\\000\\000\\207\\000\\244\\001\\000\\000\\225\\000\\203\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\232\\000\\000\\000\\232\\000\\000\\000\\225\\001\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\217\\000\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\225\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\230\\000\\\n \\000\\000\\230\\000\\000\\000\\228\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\000\\000\\228\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\186\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\241\\000\\000\\000\\\n \\113\\001\\000\\000\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\000\\000\\112\\001\\\n \\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\112\\001\\\n \\000\\000\\000\\000\\000\\000\\240\\000\\200\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\000\\000\\246\\000\\000\\000\\000\\000\\240\\000\\000\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\245\\000\\000\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\238\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\069\\001\\070\\001\\000\\000\\000\\000\\069\\001\\076\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\069\\001\\\n \\000\\000\\078\\001\\000\\000\\000\\000\\000\\000\\000\\000\\104\\001\\073\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\079\\001\\000\\000\\071\\001\\076\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\000\\000\\000\\000\\072\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\243\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\080\\001\\119\\001\\000\\000\\119\\001\\000\\000\\081\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\000\\000\\000\\000\\074\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\083\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\082\\001\\000\\000\\000\\000\\\n \\115\\001\\000\\000\\000\\000\\084\\001\\000\\000\\000\\000\\117\\001\\000\\000\\\n \\117\\001\\000\\000\\075\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\000\\000\\\n \\115\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\000\\000\\\n \\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\\n \\000\\000\\185\\001\\000\\000\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\\n \\184\\001\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\128\\001\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\128\\001\\128\\001\\000\\000\\000\\000\\068\\001\\\n \\128\\001\\128\\001\\128\\001\\127\\001\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\184\\001\\000\\000\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\\n \\000\\000\\128\\001\\000\\000\\128\\001\\127\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\000\\000\\000\\000\\000\\000\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\128\\001\\128\\001\\128\\001\\000\\000\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\191\\001\\142\\001\\191\\001\\000\\000\\000\\000\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\000\\000\\128\\001\\128\\001\\128\\001\\128\\001\\128\\001\\\n \\128\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\\n \\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\141\\001\\000\\000\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\146\\001\\147\\001\\\n \\000\\000\\000\\000\\146\\001\\154\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\146\\001\\000\\000\\153\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\177\\001\\150\\001\\000\\000\\000\\000\\\n \\000\\000\\200\\001\\156\\001\\000\\000\\148\\001\\154\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\000\\000\\\n \\000\\000\\149\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\139\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\157\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\158\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\200\\001\\000\\000\\\n \\151\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\187\\001\\000\\000\\160\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\159\\001\\200\\001\\000\\000\\200\\001\\199\\001\\\n \\000\\000\\161\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\152\\001\\000\\000\\000\\000\\000\\000\\000\\000\\189\\001\\000\\000\\189\\001\\\n \\000\\000\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\145\\001\\200\\001\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\200\\001\\000\\000\\000\\000\\000\\000\\200\\001\\000\\000\\\n \\200\\001\\199\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\000\\000\\000\\000\\000\\000\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\200\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\\n \\200\\001\\000\\000\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\000\\000\\214\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\200\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\000\\000\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\213\\001\\\n \\000\\000\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\211\\001\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\";\n Lexing.lex_check = \n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\255\\255\\003\\000\\000\\000\\134\\000\\255\\255\\\n \\003\\000\\255\\255\\134\\000\\069\\001\\146\\001\\057\\000\\255\\255\\069\\001\\\n \\146\\001\\255\\255\\255\\255\\255\\255\\255\\255\\125\\000\\138\\000\\255\\255\\\n \\000\\000\\255\\255\\000\\000\\003\\000\\169\\000\\134\\000\\174\\000\\255\\255\\\n \\000\\000\\010\\001\\069\\001\\146\\001\\012\\001\\000\\000\\010\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\005\\000\\115\\000\\000\\000\\125\\000\\129\\000\\005\\000\\\n \\236\\001\\136\\000\\255\\001\\038\\000\\255\\255\\010\\000\\136\\000\\102\\000\\\n \\058\\000\\000\\000\\107\\000\\102\\000\\255\\255\\011\\000\\000\\000\\011\\000\\\n \\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\011\\000\\029\\000\\038\\000\\000\\000\\111\\000\\208\\000\\233\\000\\255\\000\\\n \\012\\001\\015\\000\\017\\000\\060\\000\\011\\000\\010\\000\\000\\000\\020\\000\\\n \\024\\000\\031\\000\\032\\000\\034\\000\\022\\000\\026\\000\\000\\000\\014\\000\\\n \\027\\000\\033\\000\\018\\000\\023\\000\\000\\000\\016\\000\\019\\000\\035\\000\\\n \\040\\000\\036\\000\\038\\000\\000\\000\\041\\000\\042\\000\\043\\000\\044\\000\\\n \\045\\000\\046\\000\\058\\000\\082\\000\\011\\000\\013\\000\\013\\000\\013\\000\\\n \\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\013\\000\\039\\000\\\n \\063\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\085\\000\\140\\000\\060\\000\\013\\000\\143\\000\\\n \\144\\000\\145\\000\\048\\000\\147\\000\\048\\000\\148\\000\\039\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\\n \\048\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\065\\000\\039\\000\\149\\000\\\n \\150\\000\\156\\000\\063\\000\\157\\000\\051\\000\\158\\000\\051\\000\\159\\000\\\n \\050\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\051\\000\\\n \\051\\000\\051\\000\\051\\000\\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\\n \\052\\000\\052\\000\\052\\000\\052\\000\\052\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\053\\000\\155\\000\\\n \\050\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\054\\000\\\n \\054\\000\\054\\000\\054\\000\\161\\000\\162\\000\\155\\000\\091\\000\\065\\000\\\n \\000\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\055\\000\\\n \\055\\000\\055\\000\\055\\000\\057\\000\\068\\000\\102\\000\\107\\000\\115\\000\\\n \\131\\000\\133\\000\\133\\000\\125\\000\\138\\000\\133\\000\\163\\000\\094\\000\\\n \\165\\000\\068\\000\\166\\000\\167\\000\\168\\000\\171\\000\\111\\000\\172\\000\\\n \\173\\000\\206\\000\\203\\000\\207\\000\\210\\000\\211\\000\\058\\000\\082\\000\\\n \\133\\000\\212\\000\\213\\000\\214\\000\\215\\000\\217\\000\\140\\000\\218\\000\\\n \\097\\000\\219\\000\\220\\000\\119\\000\\221\\000\\222\\000\\223\\000\\133\\000\\\n \\091\\000\\203\\000\\034\\001\\062\\001\\233\\000\\152\\000\\001\\001\\080\\001\\\n \\247\\000\\060\\000\\251\\000\\054\\001\\058\\001\\081\\001\\068\\000\\041\\001\\\n \\082\\001\\083\\001\\006\\001\\026\\001\\068\\000\\119\\000\\030\\001\\015\\001\\\n \\068\\000\\094\\000\\015\\001\\084\\001\\085\\001\\086\\001\\071\\001\\088\\001\\\n \\068\\000\\203\\000\\050\\001\\071\\001\\068\\000\\089\\001\\068\\000\\068\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\097\\000\\076\\001\\119\\000\\090\\001\\063\\000\\001\\001\\\n \\092\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\152\\000\\076\\001\\093\\001\\095\\001\\097\\001\\098\\001\\045\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\099\\001\\152\\000\\\n \\100\\001\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\020\\001\\076\\001\\065\\000\\020\\001\\101\\001\\102\\001\\104\\001\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\105\\001\\106\\001\\045\\001\\036\\001\\107\\001\\108\\001\\109\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\110\\001\\\n \\026\\001\\121\\001\\157\\001\\030\\001\\158\\001\\020\\001\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\091\\000\\159\\001\\062\\001\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\247\\000\\160\\001\\251\\000\\\n \\161\\001\\058\\001\\068\\000\\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\086\\000\\086\\000\\086\\000\\094\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\036\\001\\041\\001\\097\\000\\162\\001\\\n \\163\\001\\119\\000\\001\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\165\\001\\054\\001\\152\\000\\086\\000\\086\\000\\086\\000\\086\\000\\\n \\086\\000\\086\\000\\006\\001\\166\\001\\167\\001\\168\\001\\015\\001\\169\\001\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\050\\001\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\095\\000\\133\\001\\170\\001\\171\\001\\154\\001\\133\\001\\172\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\095\\000\\176\\000\\\n \\173\\001\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\045\\001\\\n \\174\\001\\175\\001\\176\\000\\176\\001\\154\\001\\176\\000\\176\\000\\176\\000\\\n \\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\176\\000\\122\\001\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\148\\001\\177\\001\\\n \\020\\001\\178\\001\\098\\000\\148\\001\\179\\001\\180\\001\\181\\001\\182\\001\\\n \\183\\001\\216\\001\\193\\001\\095\\000\\154\\001\\216\\001\\205\\001\\098\\000\\\n \\222\\001\\095\\000\\205\\001\\229\\001\\001\\002\\095\\000\\218\\001\\036\\001\\\n \\215\\001\\215\\001\\002\\002\\218\\001\\215\\001\\095\\000\\003\\002\\005\\002\\\n \\216\\001\\095\\000\\006\\002\\095\\000\\095\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\215\\001\\\n \\007\\002\\122\\001\\008\\002\\009\\002\\010\\002\\011\\002\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\098\\000\\012\\002\\215\\001\\247\\001\\\n \\013\\002\\014\\002\\098\\000\\015\\002\\125\\001\\128\\001\\098\\000\\016\\002\\\n \\220\\001\\017\\002\\251\\001\\018\\002\\019\\002\\020\\002\\098\\000\\121\\001\\\n \\021\\002\\194\\001\\098\\000\\022\\002\\098\\000\\098\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\231\\001\\023\\002\\\n \\238\\001\\024\\002\\251\\001\\238\\001\\025\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\243\\001\\125\\001\\128\\001\\\n \\224\\001\\026\\002\\197\\001\\027\\002\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\028\\002\\194\\001\\029\\002\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\030\\002\\031\\002\\032\\002\\200\\001\\231\\001\\\n \\133\\001\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\101\\000\\101\\000\\101\\000\\033\\002\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\255\\255\\255\\255\\197\\001\\176\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\185\\000\\255\\255\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\101\\000\\\n \\200\\001\\224\\001\\255\\255\\185\\000\\205\\001\\122\\001\\185\\000\\185\\000\\\n \\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\\n \\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\190\\000\\\n \\190\\000\\190\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\191\\000\\\n \\191\\000\\191\\000\\191\\000\\191\\000\\192\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\192\\000\\\n \\193\\001\\247\\001\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\\n \\192\\000\\192\\000\\192\\000\\192\\000\\198\\000\\198\\000\\198\\000\\198\\000\\\n \\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\199\\000\\226\\000\\\n \\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\\n \\226\\000\\199\\000\\125\\001\\128\\001\\199\\000\\199\\000\\199\\000\\199\\000\\\n \\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\199\\000\\204\\000\\194\\001\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\231\\001\\255\\255\\255\\255\\199\\000\\220\\001\\238\\001\\\n \\251\\001\\255\\255\\199\\000\\243\\001\\255\\255\\204\\000\\205\\000\\205\\000\\\n \\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\\n \\225\\000\\255\\255\\225\\000\\255\\255\\224\\001\\225\\000\\225\\000\\225\\000\\\n \\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\205\\000\\\n \\197\\001\\255\\255\\255\\255\\255\\255\\255\\255\\204\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\200\\001\\255\\255\\255\\255\\228\\000\\\n \\255\\255\\228\\000\\255\\255\\227\\000\\228\\000\\228\\000\\228\\000\\228\\000\\\n \\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\228\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\\n \\230\\000\\230\\000\\255\\255\\227\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\185\\000\\232\\000\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\237\\000\\255\\255\\\n \\077\\001\\255\\255\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\077\\001\\\n \\077\\001\\077\\001\\077\\001\\077\\001\\113\\001\\113\\001\\113\\001\\113\\001\\\n \\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\113\\001\\255\\255\\077\\001\\\n \\255\\255\\255\\255\\192\\000\\255\\255\\255\\255\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\077\\001\\\n \\255\\255\\255\\255\\255\\255\\237\\000\\199\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\\n \\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\237\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\255\\255\\242\\000\\255\\255\\255\\255\\240\\000\\255\\255\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\240\\000\\\n \\240\\000\\240\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\242\\000\\255\\255\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\242\\000\\\n \\242\\000\\242\\000\\242\\000\\242\\000\\237\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\245\\000\\255\\255\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\245\\000\\\n \\066\\001\\066\\001\\255\\255\\255\\255\\066\\001\\079\\001\\079\\001\\079\\001\\\n \\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\079\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\\n \\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\079\\001\\066\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\066\\001\\066\\001\\\n \\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\066\\001\\\n \\066\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\242\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\066\\001\\112\\001\\255\\255\\112\\001\\255\\255\\066\\001\\112\\001\\112\\001\\\n \\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\112\\001\\\n \\255\\255\\255\\255\\066\\001\\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\\n \\114\\001\\114\\001\\114\\001\\114\\001\\114\\001\\066\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\\n \\114\\001\\255\\255\\255\\255\\066\\001\\255\\255\\255\\255\\115\\001\\255\\255\\\n \\115\\001\\255\\255\\066\\001\\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\\n \\115\\001\\115\\001\\115\\001\\115\\001\\115\\001\\116\\001\\116\\001\\116\\001\\\n \\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\116\\001\\255\\255\\\n \\114\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\117\\001\\\n \\117\\001\\117\\001\\117\\001\\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\\n \\118\\001\\118\\001\\118\\001\\118\\001\\118\\001\\119\\001\\119\\001\\119\\001\\\n \\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\119\\001\\255\\255\\\n \\126\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\127\\001\\127\\001\\127\\001\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\\n \\255\\255\\155\\001\\255\\255\\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\\n \\155\\001\\155\\001\\155\\001\\155\\001\\155\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\127\\001\\\n \\155\\001\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\126\\001\\255\\255\\255\\255\\255\\255\\126\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\129\\001\\126\\001\\255\\255\\255\\255\\066\\001\\\n \\126\\001\\129\\001\\126\\001\\126\\001\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\155\\001\\255\\255\\255\\255\\255\\255\\255\\255\\129\\001\\255\\255\\255\\255\\\n \\255\\255\\129\\001\\255\\255\\129\\001\\129\\001\\130\\001\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\131\\001\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\255\\255\\255\\255\\255\\255\\130\\001\\130\\001\\\n \\130\\001\\130\\001\\130\\001\\130\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\132\\001\\132\\001\\132\\001\\255\\255\\131\\001\\131\\001\\131\\001\\\n \\131\\001\\131\\001\\131\\001\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\184\\001\\138\\001\\184\\001\\255\\255\\255\\255\\184\\001\\184\\001\\\n \\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\184\\001\\\n \\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\185\\001\\\n \\185\\001\\185\\001\\255\\255\\132\\001\\132\\001\\132\\001\\132\\001\\132\\001\\\n \\132\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\138\\001\\\n \\255\\255\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\138\\001\\\n \\138\\001\\138\\001\\138\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\141\\001\\255\\255\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\\n \\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\141\\001\\143\\001\\143\\001\\\n \\255\\255\\255\\255\\143\\001\\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\\n \\156\\001\\156\\001\\156\\001\\156\\001\\156\\001\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\156\\001\\143\\001\\255\\255\\255\\255\\\n \\255\\255\\198\\001\\143\\001\\255\\255\\143\\001\\143\\001\\143\\001\\143\\001\\\n \\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\143\\001\\255\\255\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\138\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\143\\001\\186\\001\\186\\001\\186\\001\\186\\001\\\n \\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\186\\001\\198\\001\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\198\\001\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\186\\001\\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\198\\001\\255\\255\\255\\255\\143\\001\\198\\001\\255\\255\\198\\001\\198\\001\\\n \\255\\255\\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\143\\001\\255\\255\\255\\255\\255\\255\\255\\255\\187\\001\\255\\255\\187\\001\\\n \\255\\255\\186\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\187\\001\\\n \\187\\001\\187\\001\\187\\001\\187\\001\\188\\001\\188\\001\\188\\001\\188\\001\\\n \\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\188\\001\\189\\001\\189\\001\\\n \\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\\n \\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\190\\001\\\n \\190\\001\\190\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\191\\001\\\n \\191\\001\\191\\001\\191\\001\\191\\001\\199\\001\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\199\\001\\199\\001\\199\\001\\\n \\199\\001\\199\\001\\199\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\143\\001\\201\\001\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\201\\001\\255\\255\\255\\255\\255\\255\\201\\001\\255\\255\\\n \\201\\001\\201\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\202\\001\\202\\001\\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\203\\001\\203\\001\\203\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\255\\255\\255\\255\\255\\255\\202\\001\\202\\001\\202\\001\\202\\001\\202\\001\\\n \\202\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\204\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\\n \\204\\001\\255\\255\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\203\\001\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\255\\255\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\204\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\210\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\213\\001\\\n \\255\\255\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\213\\001\\\n \\213\\001\\213\\001\\213\\001\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\210\\001\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\";\n Lexing.lex_base_code = \n \"\";\n Lexing.lex_backtrk_code = \n \"\";\n Lexing.lex_default_code = \n \"\";\n Lexing.lex_trans_code = \n \"\";\n Lexing.lex_check_code = \n \"\";\n Lexing.lex_code = \n \"\";\n}\n\nlet rec read_json v lexbuf =\n __ocaml_lex_read_json_rec v lexbuf 0\nand __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 188 \"read.mll\"\n ( `Bool true )\n# 1032 \"read.ml\"\n\n | 1 ->\n# 189 \"read.mll\"\n ( `Bool false )\n# 1037 \"read.ml\"\n\n | 2 ->\n# 190 \"read.mll\"\n ( `Null )\n# 1042 \"read.ml\"\n\n | 3 ->\n# 191 \"read.mll\"\n (\n #ifdef FLOAT\n `Float nan\n #elif defined FLOATLIT\n `Floatlit \"NaN\"\n #endif\n )\n# 1053 \"read.ml\"\n\n | 4 ->\n# 198 \"read.mll\"\n (\n #ifdef FLOAT\n `Float infinity\n #elif defined FLOATLIT\n `Floatlit \"Infinity\"\n #endif\n )\n# 1064 \"read.ml\"\n\n | 5 ->\n# 205 \"read.mll\"\n (\n #ifdef FLOAT\n `Float neg_infinity\n #elif defined FLOATLIT\n `Floatlit \"-Infinity\"\n #endif\n )\n# 1075 \"read.ml\"\n\n | 6 ->\n# 212 \"read.mll\"\n (\n #ifdef STRING\n Bi_outbuf.clear v.buf;\n `String (finish_string v lexbuf)\n #elif defined STRINGLIT\n `Stringlit (finish_stringlit v lexbuf)\n #endif\n )\n# 1087 \"read.ml\"\n\n | 7 ->\n# 220 \"read.mll\"\n ( make_positive_int v lexbuf )\n# 1092 \"read.ml\"\n\n | 8 ->\n# 221 \"read.mll\"\n ( make_negative_int v lexbuf )\n# 1097 \"read.ml\"\n\n | 9 ->\n# 222 \"read.mll\"\n (\n #ifdef FLOAT\n `Float (float_of_string (lexeme lexbuf))\n #elif defined FLOATLIT\n `Floatlit (lexeme lexbuf)\n #endif\n )\n# 1108 \"read.ml\"\n\n | 10 ->\n# 230 \"read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_ident v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := (field_name, read_json v lexbuf) :: !acc;\n done;\n assert false\n with End_of_object ->\n `Assoc (List.rev !acc)\n )\n# 1135 \"read.ml\"\n\n | 11 ->\n# 254 \"read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n `List (List.rev !acc)\n )\n# 1154 \"read.ml\"\n\n | 12 ->\n# 270 \"read.mll\"\n (\n #ifdef TUPLE\n let acc = ref [] in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_json v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_json v lexbuf :: !acc;\n done;\n assert false\n with End_of_tuple ->\n `Tuple (List.rev !acc)\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 1178 \"read.ml\"\n\n | 13 ->\n# 291 \"read.mll\"\n (\n #ifdef VARIANT\n read_space v lexbuf;\n let cons = read_ident v lexbuf in\n read_space v lexbuf;\n `Variant (cons, finish_variant v lexbuf)\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 1192 \"read.ml\"\n\n | 14 ->\n# 302 \"read.mll\"\n ( read_json v lexbuf )\n# 1197 \"read.ml\"\n\n | 15 ->\n# 303 \"read.mll\"\n ( finish_comment v lexbuf; read_json v lexbuf )\n# 1202 \"read.ml\"\n\n | 16 ->\n# 304 \"read.mll\"\n ( newline v lexbuf; read_json v lexbuf )\n# 1207 \"read.ml\"\n\n | 17 ->\n# 305 \"read.mll\"\n ( read_json v lexbuf )\n# 1212 \"read.ml\"\n\n | 18 ->\n# 306 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1217 \"read.ml\"\n\n | 19 ->\n# 307 \"read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n# 1222 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_json_rec v lexbuf __ocaml_lex_state\n\nand finish_string v lexbuf =\n __ocaml_lex_finish_string_rec v lexbuf 58\nand __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 311 \"read.mll\"\n ( Bi_outbuf.contents v.buf )\n# 1234 \"read.ml\"\n\n | 1 ->\n# 312 \"read.mll\"\n ( finish_escaped_char v lexbuf;\n finish_string v lexbuf )\n# 1240 \"read.ml\"\n\n | 2 ->\n# 314 \"read.mll\"\n ( add_lexeme v.buf lexbuf;\n finish_string v lexbuf )\n# 1246 \"read.ml\"\n\n | 3 ->\n# 316 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1251 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_string_rec v lexbuf __ocaml_lex_state\n\nand map_string v f lexbuf =\n __ocaml_lex_map_string_rec v f lexbuf 63\nand __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 319 \"read.mll\"\n ( let b = v.buf in\n f b.Bi_outbuf.o_s 0 b.Bi_outbuf.o_len )\n# 1264 \"read.ml\"\n\n | 1 ->\n# 321 \"read.mll\"\n ( finish_escaped_char v lexbuf;\n map_string v f lexbuf )\n# 1270 \"read.ml\"\n\n | 2 ->\n# 323 \"read.mll\"\n ( add_lexeme v.buf lexbuf;\n map_string v f lexbuf )\n# 1276 \"read.ml\"\n\n | 3 ->\n# 325 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1281 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_map_string_rec v f lexbuf __ocaml_lex_state\n\nand finish_escaped_char v lexbuf =\n __ocaml_lex_finish_escaped_char_rec v lexbuf 68\nand __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n# 330 \"read.mll\"\n c\n# 1294 \"read.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n# 330 \"read.mll\"\n ( Bi_outbuf.add_char v.buf c )\n# 1298 \"read.ml\"\n\n | 1 ->\n# 331 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '\\b' )\n# 1303 \"read.ml\"\n\n | 2 ->\n# 332 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '\\012' )\n# 1308 \"read.ml\"\n\n | 3 ->\n# 333 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n' )\n# 1313 \"read.ml\"\n\n | 4 ->\n# 334 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '\\r' )\n# 1318 \"read.ml\"\n\n | 5 ->\n# 335 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '\\t' )\n# 1323 \"read.ml\"\n\n | 6 ->\nlet\n# 336 \"read.mll\"\n a\n# 1329 \"read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)\nand\n# 336 \"read.mll\"\n b\n# 1334 \"read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n# 336 \"read.mll\"\n c\n# 1339 \"read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n# 336 \"read.mll\"\n d\n# 1344 \"read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4) in\n# 337 \"read.mll\"\n ( let x =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if x >= 0xD800 && x <= 0xDBFF then\n finish_surrogate_pair v x lexbuf\n else\n utf8_of_code v.buf x\n )\n# 1355 \"read.ml\"\n\n | 7 ->\n# 345 \"read.mll\"\n ( long_error \"Invalid escape sequence\" v lexbuf )\n# 1360 \"read.ml\"\n\n | 8 ->\n# 346 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1365 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_escaped_char_rec v lexbuf __ocaml_lex_state\n\nand finish_surrogate_pair v x lexbuf =\n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf 82\nand __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n# 349 \"read.mll\"\n a\n# 1378 \"read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n# 349 \"read.mll\"\n b\n# 1383 \"read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n# 349 \"read.mll\"\n c\n# 1388 \"read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4)\nand\n# 349 \"read.mll\"\n d\n# 1393 \"read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 5) in\n# 350 \"read.mll\"\n ( let y =\n (hex a lsl 12) lor (hex b lsl 8) lor (hex c lsl 4) lor hex d\n in\n if y >= 0xDC00 && y <= 0xDFFF then\n utf8_of_surrogate_pair v.buf x y\n else\n long_error \"Invalid low surrogate for code point beyond U+FFFF\"\n v lexbuf\n )\n# 1405 \"read.ml\"\n\n | 1 ->\n# 359 \"read.mll\"\n ( long_error \"Missing escape sequence representing low surrogate \\\n for code point beyond U+FFFF\" v lexbuf )\n# 1411 \"read.ml\"\n\n | 2 ->\n# 361 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1416 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_surrogate_pair_rec v x lexbuf __ocaml_lex_state\n\nand finish_stringlit v lexbuf =\n __ocaml_lex_finish_stringlit_rec v lexbuf 91\nand __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 366 \"read.mll\"\n ( let len = lexbuf.lex_curr_pos - lexbuf.lex_start_pos in\n let s = String.create (len+1) in\n s.[0] <- '\"';\n String.blit lexbuf.lex_buffer lexbuf.lex_start_pos s 1 len;\n s\n )\n# 1433 \"read.ml\"\n\n | 1 ->\n# 372 \"read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n# 1438 \"read.ml\"\n\n | 2 ->\n# 373 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1443 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_variant v lexbuf =\n __ocaml_lex_finish_variant_rec v lexbuf 102\nand __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 376 \"read.mll\"\n ( let x = read_json v lexbuf in\n read_space v lexbuf;\n read_gt v lexbuf;\n Some x )\n# 1458 \"read.ml\"\n\n | 1 ->\n# 380 \"read.mll\"\n ( None )\n# 1463 \"read.ml\"\n\n | 2 ->\n# 381 \"read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n# 1468 \"read.ml\"\n\n | 3 ->\n# 382 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1473 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_variant_rec v lexbuf __ocaml_lex_state\n\nand read_lt v lexbuf =\n __ocaml_lex_read_lt_rec v lexbuf 107\nand __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 385 \"read.mll\"\n ( () )\n# 1485 \"read.ml\"\n\n | 1 ->\n# 386 \"read.mll\"\n ( long_error \"Expected '<' but found\" v lexbuf )\n# 1490 \"read.ml\"\n\n | 2 ->\n# 387 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1495 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_lt_rec v lexbuf __ocaml_lex_state\n\nand read_gt v lexbuf =\n __ocaml_lex_read_gt_rec v lexbuf 111\nand __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 390 \"read.mll\"\n ( () )\n# 1507 \"read.ml\"\n\n | 1 ->\n# 391 \"read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n# 1512 \"read.ml\"\n\n | 2 ->\n# 392 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1517 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_gt_rec v lexbuf __ocaml_lex_state\n\nand read_comma v lexbuf =\n __ocaml_lex_read_comma_rec v lexbuf 115\nand __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 395 \"read.mll\"\n ( () )\n# 1529 \"read.ml\"\n\n | 1 ->\n# 396 \"read.mll\"\n ( long_error \"Expected ',' but found\" v lexbuf )\n# 1534 \"read.ml\"\n\n | 2 ->\n# 397 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1539 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_comma_rec v lexbuf __ocaml_lex_state\n\nand start_any_variant v lexbuf =\n __ocaml_lex_start_any_variant_rec v lexbuf 119\nand __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 400 \"read.mll\"\n ( `Edgy_bracket )\n# 1551 \"read.ml\"\n\n | 1 ->\n# 401 \"read.mll\"\n ( Bi_outbuf.clear v.buf;\n `Double_quote )\n# 1557 \"read.ml\"\n\n | 2 ->\n# 403 \"read.mll\"\n ( `Square_bracket )\n# 1562 \"read.ml\"\n\n | 3 ->\n# 404 \"read.mll\"\n ( long_error \"Expected '<', '\\\"' or '[' but found\" v lexbuf )\n# 1567 \"read.ml\"\n\n | 4 ->\n# 405 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1572 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_start_any_variant_rec v lexbuf __ocaml_lex_state\n\nand finish_comment v lexbuf =\n __ocaml_lex_finish_comment_rec v lexbuf 125\nand __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 408 \"read.mll\"\n ( () )\n# 1584 \"read.ml\"\n\n | 1 ->\n# 409 \"read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n# 1589 \"read.ml\"\n\n | 2 ->\n# 410 \"read.mll\"\n ( newline v lexbuf; finish_comment v lexbuf )\n# 1594 \"read.ml\"\n\n | 3 ->\n# 411 \"read.mll\"\n ( finish_comment v lexbuf )\n# 1599 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_comment_rec v lexbuf __ocaml_lex_state\n\nand read_eof lexbuf =\n __ocaml_lex_read_eof_rec lexbuf 131\nand __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 419 \"read.mll\"\n ( true )\n# 1611 \"read.ml\"\n\n | 1 ->\n# 420 \"read.mll\"\n ( false )\n# 1616 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_eof_rec lexbuf __ocaml_lex_state\n\nand read_space v lexbuf =\n __ocaml_lex_read_space_rec v lexbuf 133\nand __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 423 \"read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n# 1628 \"read.ml\"\n\n | 1 ->\n# 424 \"read.mll\"\n ( finish_comment v lexbuf; read_space v lexbuf )\n# 1633 \"read.ml\"\n\n | 2 ->\n# 425 \"read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n# 1638 \"read.ml\"\n\n | 3 ->\n# 426 \"read.mll\"\n ( read_space v lexbuf )\n# 1643 \"read.ml\"\n\n | 4 ->\n# 427 \"read.mll\"\n ( () )\n# 1648 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_space_rec v lexbuf __ocaml_lex_state\n\nand read_null v lexbuf =\n __ocaml_lex_read_null_rec v lexbuf 140\nand __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 430 \"read.mll\"\n ( () )\n# 1660 \"read.ml\"\n\n | 1 ->\n# 431 \"read.mll\"\n ( long_error \"Expected 'null' but found\" v lexbuf )\n# 1665 \"read.ml\"\n\n | 2 ->\n# 432 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1670 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_null_rec v lexbuf __ocaml_lex_state\n\nand read_null_if_possible v lexbuf =\n __ocaml_lex_read_null_if_possible_rec v lexbuf 147\nand __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 435 \"read.mll\"\n ( true )\n# 1682 \"read.ml\"\n\n | 1 ->\n# 436 \"read.mll\"\n ( false )\n# 1687 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_null_if_possible_rec v lexbuf __ocaml_lex_state\n\nand read_bool v lexbuf =\n __ocaml_lex_read_bool_rec v lexbuf 152\nand __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 439 \"read.mll\"\n ( true )\n# 1699 \"read.ml\"\n\n | 1 ->\n# 440 \"read.mll\"\n ( false )\n# 1704 \"read.ml\"\n\n | 2 ->\n# 443 \"read.mll\"\n ( true )\n# 1709 \"read.ml\"\n\n | 3 ->\n# 444 \"read.mll\"\n ( false )\n# 1714 \"read.ml\"\n\n | 4 ->\n# 446 \"read.mll\"\n ( long_error \"Expected 'true' or 'false' but found\" v lexbuf )\n# 1719 \"read.ml\"\n\n | 5 ->\n# 447 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1724 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_bool_rec v lexbuf __ocaml_lex_state\n\nand read_int v lexbuf =\n __ocaml_lex_read_int_rec v lexbuf 176\nand __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 450 \"read.mll\"\n ( try extract_positive_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n# 1738 \"read.ml\"\n\n | 1 ->\n# 453 \"read.mll\"\n ( try extract_negative_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n# 1745 \"read.ml\"\n\n | 2 ->\n# 456 \"read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n int_of_string s\n with _ ->\n custom_error\n \"Expected an integer but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n# 1763 \"read.ml\"\n\n | 3 ->\n# 470 \"read.mll\"\n ( long_error \"Expected integer but found\" v lexbuf )\n# 1768 \"read.ml\"\n\n | 4 ->\n# 471 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1773 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_int_rec v lexbuf __ocaml_lex_state\n\nand read_int32 v lexbuf =\n __ocaml_lex_read_int32_rec v lexbuf 185\nand __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 474 \"read.mll\"\n ( try Int32.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n# 1787 \"read.ml\"\n\n | 1 ->\n# 477 \"read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int32.of_string s\n with _ ->\n custom_error\n \"Expected an int32 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n# 1805 \"read.ml\"\n\n | 2 ->\n# 491 \"read.mll\"\n ( long_error \"Expected int32 but found\" v lexbuf )\n# 1810 \"read.ml\"\n\n | 3 ->\n# 492 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1815 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_int32_rec v lexbuf __ocaml_lex_state\n\nand read_int64 v lexbuf =\n __ocaml_lex_read_int64_rec v lexbuf 192\nand __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 495 \"read.mll\"\n ( try Int64.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n# 1829 \"read.ml\"\n\n | 1 ->\n# 498 \"read.mll\"\n ( (* Support for double-quoted \"ints\" *)\n Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant int will pass,\n including hexadecimal and octal notations,\n and embedded underscores *)\n Int64.of_string s\n with _ ->\n custom_error\n \"Expected an int64 but found a string that \\\n doesn't even represent an integer\"\n v lexbuf\n )\n# 1847 \"read.ml\"\n\n | 2 ->\n# 512 \"read.mll\"\n ( long_error \"Expected int64 but found\" v lexbuf )\n# 1852 \"read.ml\"\n\n | 3 ->\n# 513 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1857 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_int64_rec v lexbuf __ocaml_lex_state\n\nand read_number v lexbuf =\n __ocaml_lex_read_number_rec v lexbuf 199\nand __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 516 \"read.mll\"\n ( nan )\n# 1869 \"read.ml\"\n\n | 1 ->\n# 517 \"read.mll\"\n ( infinity )\n# 1874 \"read.ml\"\n\n | 2 ->\n# 518 \"read.mll\"\n ( neg_infinity )\n# 1879 \"read.ml\"\n\n | 3 ->\n# 519 \"read.mll\"\n ( float_of_string (lexeme lexbuf) )\n# 1884 \"read.ml\"\n\n | 4 ->\n# 520 \"read.mll\"\n ( Bi_outbuf.clear v.buf;\n let s = finish_string v lexbuf in\n try\n (* Any OCaml-compliant float will pass,\n including hexadecimal and octal notations,\n and embedded underscores. *)\n float_of_string s\n with _ ->\n match s with\n \"NaN\" -> nan\n | \"Infinity\" -> infinity\n | \"-Infinity\" -> neg_infinity\n | _ ->\n custom_error\n \"Expected a number but found a string that \\\n doesn't even represent a number\"\n v lexbuf\n )\n# 1906 \"read.ml\"\n\n | 5 ->\n# 538 \"read.mll\"\n ( long_error \"Expected number but found\" v lexbuf )\n# 1911 \"read.ml\"\n\n | 6 ->\n# 539 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1916 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_number_rec v lexbuf __ocaml_lex_state\n\nand read_string v lexbuf =\n __ocaml_lex_read_string_rec v lexbuf 233\nand __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 542 \"read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n# 1929 \"read.ml\"\n\n | 1 ->\n# 544 \"read.mll\"\n ( long_error \"Expected '\\\"' but found\" v lexbuf )\n# 1934 \"read.ml\"\n\n | 2 ->\n# 545 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1939 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_string_rec v lexbuf __ocaml_lex_state\n\nand read_ident v lexbuf =\n __ocaml_lex_read_ident_rec v lexbuf 237\nand __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 548 \"read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n# 1952 \"read.ml\"\n\n | 1 ->\nlet\n# 550 \"read.mll\"\n s\n# 1958 \"read.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 551 \"read.mll\"\n ( s )\n# 1962 \"read.ml\"\n\n | 2 ->\n# 552 \"read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n# 1967 \"read.ml\"\n\n | 3 ->\n# 553 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1972 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_ident_rec v lexbuf __ocaml_lex_state\n\nand map_ident v f lexbuf =\n __ocaml_lex_map_ident_rec v f lexbuf 242\nand __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 556 \"read.mll\"\n ( Bi_outbuf.clear v.buf;\n map_string v f lexbuf )\n# 1985 \"read.ml\"\n\n | 1 ->\n# 559 \"read.mll\"\n ( map_lexeme f lexbuf )\n# 1990 \"read.ml\"\n\n | 2 ->\n# 560 \"read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n# 1995 \"read.ml\"\n\n | 3 ->\n# 561 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2000 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_map_ident_rec v f lexbuf __ocaml_lex_state\n\nand read_sequence read_cell init_acc v lexbuf =\n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf 247\nand __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 564 \"read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell !acc v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !acc v lexbuf;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n# 2026 \"read.ml\"\n\n | 1 ->\n# 579 \"read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n# 2031 \"read.ml\"\n\n | 2 ->\n# 580 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2036 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_sequence_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_list_rev read_cell v lexbuf =\n __ocaml_lex_read_list_rev_rec read_cell v lexbuf 251\nand __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 583 \"read.mll\"\n ( let acc = ref [] in\n try\n read_space v lexbuf;\n read_array_end lexbuf;\n acc := read_cell v lexbuf :: !acc;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell v lexbuf :: !acc;\n done;\n assert false\n with End_of_array ->\n !acc\n )\n# 2062 \"read.ml\"\n\n | 1 ->\n# 598 \"read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n# 2067 \"read.ml\"\n\n | 2 ->\n# 599 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2072 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_list_rev_rec read_cell v lexbuf __ocaml_lex_state\n\nand read_array_end lexbuf =\n __ocaml_lex_read_array_end_rec lexbuf 255\nand __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 602 \"read.mll\"\n ( raise End_of_array )\n# 2084 \"read.ml\"\n\n | 1 ->\n# 603 \"read.mll\"\n ( () )\n# 2089 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_array_end_rec lexbuf __ocaml_lex_state\n\nand read_array_sep v lexbuf =\n __ocaml_lex_read_array_sep_rec v lexbuf 257\nand __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 606 \"read.mll\"\n ( () )\n# 2101 \"read.ml\"\n\n | 1 ->\n# 607 \"read.mll\"\n ( raise End_of_array )\n# 2106 \"read.ml\"\n\n | 2 ->\n# 608 \"read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n# 2111 \"read.ml\"\n\n | 3 ->\n# 609 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2116 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_array_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple read_cell init_acc v lexbuf =\n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf 262\nand __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 613 \"read.mll\"\n (\n #ifdef TUPLE\n let pos = ref 0 in\n let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n acc := read_cell !pos !acc v lexbuf;\n incr pos;\n done;\n assert false\n with End_of_tuple ->\n !acc\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 2150 \"read.ml\"\n\n | 1 ->\n# 636 \"read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n# 2155 \"read.ml\"\n\n | 2 ->\n# 637 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2160 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_tuple_rec read_cell init_acc v lexbuf __ocaml_lex_state\n\nand read_tuple_end lexbuf =\n __ocaml_lex_read_tuple_end_rec lexbuf 266\nand __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 640 \"read.mll\"\n ( raise End_of_tuple )\n# 2172 \"read.ml\"\n\n | 1 ->\n# 641 \"read.mll\"\n ( () )\n# 2177 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_tuple_end_rec lexbuf __ocaml_lex_state\n\nand read_tuple_end2 v std lexbuf =\n __ocaml_lex_read_tuple_end2_rec v std lexbuf 268\nand __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 644 \"read.mll\"\n ( if std then\n long_error \"Expected ')' or '' but found\" v lexbuf\n else\n raise End_of_tuple )\n# 2192 \"read.ml\"\n\n | 1 ->\n# 648 \"read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ']' or '' but found\" v lexbuf )\n# 2200 \"read.ml\"\n\n | 2 ->\n# 652 \"read.mll\"\n ( () )\n# 2205 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_tuple_end2_rec v std lexbuf __ocaml_lex_state\n\nand read_tuple_sep v lexbuf =\n __ocaml_lex_read_tuple_sep_rec v lexbuf 271\nand __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 655 \"read.mll\"\n ( () )\n# 2217 \"read.ml\"\n\n | 1 ->\n# 656 \"read.mll\"\n ( raise End_of_tuple )\n# 2222 \"read.ml\"\n\n | 2 ->\n# 657 \"read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n# 2227 \"read.ml\"\n\n | 3 ->\n# 658 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2232 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand read_tuple_sep2 v std lexbuf =\n __ocaml_lex_read_tuple_sep2_rec v std lexbuf 276\nand __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 661 \"read.mll\"\n ( () )\n# 2244 \"read.ml\"\n\n | 1 ->\n# 662 \"read.mll\"\n ( if std then\n long_error \"Expected ',' or ']' but found\" v lexbuf\n else\n raise End_of_tuple )\n# 2252 \"read.ml\"\n\n | 2 ->\n# 666 \"read.mll\"\n ( if std then\n raise End_of_tuple\n else\n long_error \"Expected ',' or ')' but found\" v lexbuf )\n# 2260 \"read.ml\"\n\n | 3 ->\n# 670 \"read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n# 2265 \"read.ml\"\n\n | 4 ->\n# 671 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2270 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_tuple_sep2_rec v std lexbuf __ocaml_lex_state\n\nand read_abstract_fields read_key read_field init_acc v lexbuf =\n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf 282\nand __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 675 \"read.mll\"\n ( let acc = ref init_acc in\n try\n read_space v lexbuf;\n read_object_end lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n let field_name = read_key v lexbuf in\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n acc := read_field !acc field_name v lexbuf;\n done;\n assert false\n with End_of_object ->\n !acc\n )\n# 2304 \"read.ml\"\n\n | 1 ->\n# 698 \"read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n# 2309 \"read.ml\"\n\n | 2 ->\n# 699 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2314 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_abstract_fields_rec read_key read_field init_acc v lexbuf __ocaml_lex_state\n\nand read_lcurl v lexbuf =\n __ocaml_lex_read_lcurl_rec v lexbuf 286\nand __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 702 \"read.mll\"\n ( () )\n# 2326 \"read.ml\"\n\n | 1 ->\n# 703 \"read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n# 2331 \"read.ml\"\n\n | 2 ->\n# 704 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2336 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_lcurl_rec v lexbuf __ocaml_lex_state\n\nand read_object_end lexbuf =\n __ocaml_lex_read_object_end_rec lexbuf 290\nand __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 707 \"read.mll\"\n ( raise End_of_object )\n# 2348 \"read.ml\"\n\n | 1 ->\n# 708 \"read.mll\"\n ( () )\n# 2353 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_object_end_rec lexbuf __ocaml_lex_state\n\nand read_object_sep v lexbuf =\n __ocaml_lex_read_object_sep_rec v lexbuf 292\nand __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 711 \"read.mll\"\n ( () )\n# 2365 \"read.ml\"\n\n | 1 ->\n# 712 \"read.mll\"\n ( raise End_of_object )\n# 2370 \"read.ml\"\n\n | 2 ->\n# 713 \"read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n# 2375 \"read.ml\"\n\n | 3 ->\n# 714 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2380 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_object_sep_rec v lexbuf __ocaml_lex_state\n\nand read_colon v lexbuf =\n __ocaml_lex_read_colon_rec v lexbuf 297\nand __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 717 \"read.mll\"\n ( () )\n# 2392 \"read.ml\"\n\n | 1 ->\n# 718 \"read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n# 2397 \"read.ml\"\n\n | 2 ->\n# 719 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2402 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_colon_rec v lexbuf __ocaml_lex_state\n\nand start_any_tuple v lexbuf =\n __ocaml_lex_start_any_tuple_rec v lexbuf 301\nand __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 722 \"read.mll\"\n ( false )\n# 2414 \"read.ml\"\n\n | 1 ->\n# 723 \"read.mll\"\n ( true )\n# 2419 \"read.ml\"\n\n | 2 ->\n# 724 \"read.mll\"\n ( long_error \"Expected '(' or '[' but found\" v lexbuf )\n# 2424 \"read.ml\"\n\n | 3 ->\n# 725 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2429 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_start_any_tuple_rec v lexbuf __ocaml_lex_state\n\nand read_lpar v lexbuf =\n __ocaml_lex_read_lpar_rec v lexbuf 306\nand __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 728 \"read.mll\"\n ( () )\n# 2441 \"read.ml\"\n\n | 1 ->\n# 729 \"read.mll\"\n ( long_error \"Expected '(' but found\" v lexbuf )\n# 2446 \"read.ml\"\n\n | 2 ->\n# 730 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2451 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_lpar_rec v lexbuf __ocaml_lex_state\n\nand read_rpar v lexbuf =\n __ocaml_lex_read_rpar_rec v lexbuf 310\nand __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 733 \"read.mll\"\n ( () )\n# 2463 \"read.ml\"\n\n | 1 ->\n# 734 \"read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n# 2468 \"read.ml\"\n\n | 2 ->\n# 735 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2473 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_rpar_rec v lexbuf __ocaml_lex_state\n\nand read_lbr v lexbuf =\n __ocaml_lex_read_lbr_rec v lexbuf 314\nand __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 738 \"read.mll\"\n ( () )\n# 2485 \"read.ml\"\n\n | 1 ->\n# 739 \"read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n# 2490 \"read.ml\"\n\n | 2 ->\n# 740 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2495 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_lbr_rec v lexbuf __ocaml_lex_state\n\nand read_rbr v lexbuf =\n __ocaml_lex_read_rbr_rec v lexbuf 318\nand __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 743 \"read.mll\"\n ( () )\n# 2507 \"read.ml\"\n\n | 1 ->\n# 744 \"read.mll\"\n ( long_error \"Expected ']' but found\" v lexbuf )\n# 2512 \"read.ml\"\n\n | 2 ->\n# 745 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2517 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_read_rbr_rec v lexbuf __ocaml_lex_state\n\nand skip_json v lexbuf =\n __ocaml_lex_skip_json_rec v lexbuf 322\nand __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 751 \"read.mll\"\n ( () )\n# 2529 \"read.ml\"\n\n | 1 ->\n# 752 \"read.mll\"\n ( () )\n# 2534 \"read.ml\"\n\n | 2 ->\n# 753 \"read.mll\"\n ( () )\n# 2539 \"read.ml\"\n\n | 3 ->\n# 754 \"read.mll\"\n ( () )\n# 2544 \"read.ml\"\n\n | 4 ->\n# 755 \"read.mll\"\n ( () )\n# 2549 \"read.ml\"\n\n | 5 ->\n# 756 \"read.mll\"\n ( () )\n# 2554 \"read.ml\"\n\n | 6 ->\n# 757 \"read.mll\"\n ( finish_skip_stringlit v lexbuf )\n# 2559 \"read.ml\"\n\n | 7 ->\n# 758 \"read.mll\"\n ( () )\n# 2564 \"read.ml\"\n\n | 8 ->\n# 759 \"read.mll\"\n ( () )\n# 2569 \"read.ml\"\n\n | 9 ->\n# 761 \"read.mll\"\n ( try\n read_space v lexbuf;\n read_object_end lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_object_sep v lexbuf;\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n read_colon v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n# 2595 \"read.ml\"\n\n | 10 ->\n# 784 \"read.mll\"\n ( try\n read_space v lexbuf;\n read_array_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_array_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n# 2613 \"read.ml\"\n\n | 11 ->\n# 799 \"read.mll\"\n (\n #ifdef TUPLE\n try\n read_space v lexbuf;\n read_tuple_end lexbuf;\n skip_json v lexbuf;\n while true do\n read_space v lexbuf;\n read_tuple_sep v lexbuf;\n read_space v lexbuf;\n skip_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 2636 \"read.ml\"\n\n | 12 ->\n# 819 \"read.mll\"\n (\n #ifdef VARIANT\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n finish_skip_variant v lexbuf\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 2650 \"read.ml\"\n\n | 13 ->\n# 830 \"read.mll\"\n ( skip_json v lexbuf )\n# 2655 \"read.ml\"\n\n | 14 ->\n# 831 \"read.mll\"\n ( finish_comment v lexbuf; skip_json v lexbuf )\n# 2660 \"read.ml\"\n\n | 15 ->\n# 832 \"read.mll\"\n ( newline v lexbuf; skip_json v lexbuf )\n# 2665 \"read.ml\"\n\n | 16 ->\n# 833 \"read.mll\"\n ( skip_json v lexbuf )\n# 2670 \"read.ml\"\n\n | 17 ->\n# 834 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2675 \"read.ml\"\n\n | 18 ->\n# 835 \"read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n# 2680 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_skip_json_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_stringlit v lexbuf =\n __ocaml_lex_finish_skip_stringlit_rec v lexbuf 378\nand __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 841 \"read.mll\"\n ( () )\n# 2692 \"read.ml\"\n\n | 1 ->\n# 842 \"read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n# 2697 \"read.ml\"\n\n | 2 ->\n# 843 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2702 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_skip_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_skip_variant v lexbuf =\n __ocaml_lex_finish_skip_variant_rec v lexbuf 389\nand __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 846 \"read.mll\"\n ( skip_json v lexbuf;\n read_space v lexbuf;\n read_gt v lexbuf )\n# 2716 \"read.ml\"\n\n | 1 ->\n# 849 \"read.mll\"\n ( () )\n# 2721 \"read.ml\"\n\n | 2 ->\n# 850 \"read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n# 2726 \"read.ml\"\n\n | 3 ->\n# 851 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2731 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_skip_variant_rec v lexbuf __ocaml_lex_state\n\nand skip_ident v lexbuf =\n __ocaml_lex_skip_ident_rec v lexbuf 394\nand __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 854 \"read.mll\"\n ( finish_skip_stringlit v lexbuf )\n# 2743 \"read.ml\"\n\n | 1 ->\n# 855 \"read.mll\"\n ( () )\n# 2748 \"read.ml\"\n\n | 2 ->\n# 856 \"read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n# 2753 \"read.ml\"\n\n | 3 ->\n# 857 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2758 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_skip_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_json v lexbuf =\n __ocaml_lex_buffer_json_rec v lexbuf 399\nand __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 870 \"read.mll\"\n ( add_lexeme v.buf lexbuf )\n# 2770 \"read.ml\"\n\n | 1 ->\n# 872 \"read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n# 2775 \"read.ml\"\n\n | 2 ->\n# 873 \"read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '{';\n buffer_space v lexbuf;\n buffer_object_end v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_object_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n buffer_colon v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_object ->\n ()\n )\n# 2802 \"read.ml\"\n\n | 3 ->\n# 897 \"read.mll\"\n ( try\n Bi_outbuf.add_char v.buf '[';\n buffer_space v lexbuf;\n buffer_array_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_array_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_array ->\n ()\n )\n# 2821 \"read.ml\"\n\n | 4 ->\n# 913 \"read.mll\"\n (\n #ifdef TUPLE\n try\n Bi_outbuf.add_char v.buf '(';\n buffer_space v lexbuf;\n buffer_tuple_end v lexbuf;\n buffer_json v lexbuf;\n while true do\n buffer_space v lexbuf;\n buffer_tuple_sep v lexbuf;\n buffer_space v lexbuf;\n buffer_json v lexbuf;\n done;\n assert false\n with End_of_tuple ->\n ()\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 2845 \"read.ml\"\n\n | 5 ->\n# 934 \"read.mll\"\n (\n #ifdef VARIANT\n Bi_outbuf.add_char v.buf '<';\n buffer_space v lexbuf;\n buffer_ident v lexbuf;\n buffer_space v lexbuf;\n finish_buffer_variant v lexbuf\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 2860 \"read.ml\"\n\n | 6 ->\n# 946 \"read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n# 2865 \"read.ml\"\n\n | 7 ->\n# 947 \"read.mll\"\n ( Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_json v lexbuf )\n# 2872 \"read.ml\"\n\n | 8 ->\n# 950 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_json v lexbuf )\n# 2879 \"read.ml\"\n\n | 9 ->\n# 953 \"read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n# 2884 \"read.ml\"\n\n | 10 ->\n# 954 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2889 \"read.ml\"\n\n | 11 ->\n# 955 \"read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n# 2894 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_json_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_stringlit v lexbuf =\n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf 450\nand __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 961 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '\"';\n add_lexeme v.buf lexbuf\n )\n# 2908 \"read.ml\"\n\n | 1 ->\n# 964 \"read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n# 2913 \"read.ml\"\n\n | 2 ->\n# 965 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2918 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_buffer_stringlit_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_variant v lexbuf =\n __ocaml_lex_finish_buffer_variant_rec v lexbuf 461\nand __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 968 \"read.mll\"\n ( Bi_outbuf.add_char v.buf ':';\n buffer_json v lexbuf;\n buffer_space v lexbuf;\n buffer_gt v lexbuf )\n# 2933 \"read.ml\"\n\n | 1 ->\n# 972 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n# 2938 \"read.ml\"\n\n | 2 ->\n# 973 \"read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n# 2943 \"read.ml\"\n\n | 3 ->\n# 974 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2948 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_buffer_variant_rec v lexbuf __ocaml_lex_state\n\nand buffer_ident v lexbuf =\n __ocaml_lex_buffer_ident_rec v lexbuf 466\nand __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 977 \"read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n# 2960 \"read.ml\"\n\n | 1 ->\n# 978 \"read.mll\"\n ( add_lexeme v.buf lexbuf )\n# 2965 \"read.ml\"\n\n | 2 ->\n# 979 \"read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n# 2970 \"read.ml\"\n\n | 3 ->\n# 980 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2975 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_ident_rec v lexbuf __ocaml_lex_state\n\nand buffer_space v lexbuf =\n __ocaml_lex_buffer_space_rec v lexbuf 471\nand __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 983 \"read.mll\"\n (\n add_lexeme v.buf lexbuf;\n newline v lexbuf;\n buffer_space v lexbuf )\n# 2990 \"read.ml\"\n\n | 1 ->\n# 987 \"read.mll\"\n (\n Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_space v lexbuf )\n# 2998 \"read.ml\"\n\n | 2 ->\n# 991 \"read.mll\"\n (\n Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_space v lexbuf )\n# 3006 \"read.ml\"\n\n | 3 ->\n# 995 \"read.mll\"\n (\n add_lexeme v.buf lexbuf;\n buffer_space v lexbuf )\n# 3013 \"read.ml\"\n\n | 4 ->\n# 998 \"read.mll\"\n ( () )\n# 3018 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_space_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_end v lexbuf =\n __ocaml_lex_buffer_object_end_rec v lexbuf 478\nand __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 1001 \"read.mll\"\n (\n Bi_outbuf.add_char v.buf '}';\n raise End_of_object )\n# 3032 \"read.ml\"\n\n | 1 ->\n# 1004 \"read.mll\"\n ( () )\n# 3037 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_object_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_object_sep v lexbuf =\n __ocaml_lex_buffer_object_sep_rec v lexbuf 480\nand __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 1007 \"read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n# 3049 \"read.ml\"\n\n | 1 ->\n# 1008 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '}'; raise End_of_object )\n# 3054 \"read.ml\"\n\n | 2 ->\n# 1009 \"read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n# 3059 \"read.ml\"\n\n | 3 ->\n# 1010 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 3064 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_object_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_end v lexbuf =\n __ocaml_lex_buffer_array_end_rec v lexbuf 485\nand __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 1013 \"read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n# 3076 \"read.ml\"\n\n | 1 ->\n# 1014 \"read.mll\"\n ( () )\n# 3081 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_array_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_array_sep v lexbuf =\n __ocaml_lex_buffer_array_sep_rec v lexbuf 487\nand __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 1017 \"read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n# 3093 \"read.ml\"\n\n | 1 ->\n# 1018 \"read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n# 3098 \"read.ml\"\n\n | 2 ->\n# 1019 \"read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n# 3103 \"read.ml\"\n\n | 3 ->\n# 1020 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 3108 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_array_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_end v lexbuf =\n __ocaml_lex_buffer_tuple_end_rec v lexbuf 492\nand __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 1023 \"read.mll\"\n (\n Bi_outbuf.add_char v.buf ')';\n raise End_of_tuple )\n# 3122 \"read.ml\"\n\n | 1 ->\n# 1026 \"read.mll\"\n ( () )\n# 3127 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_tuple_end_rec v lexbuf __ocaml_lex_state\n\nand buffer_tuple_sep v lexbuf =\n __ocaml_lex_buffer_tuple_sep_rec v lexbuf 494\nand __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 1029 \"read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n# 3139 \"read.ml\"\n\n | 1 ->\n# 1030 \"read.mll\"\n ( Bi_outbuf.add_char v.buf ')'; raise End_of_tuple )\n# 3144 \"read.ml\"\n\n | 2 ->\n# 1031 \"read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n# 3149 \"read.ml\"\n\n | 3 ->\n# 1032 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 3154 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_tuple_sep_rec v lexbuf __ocaml_lex_state\n\nand buffer_colon v lexbuf =\n __ocaml_lex_buffer_colon_rec v lexbuf 499\nand __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 1035 \"read.mll\"\n ( Bi_outbuf.add_char v.buf ':' )\n# 3166 \"read.ml\"\n\n | 1 ->\n# 1036 \"read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n# 3171 \"read.ml\"\n\n | 2 ->\n# 1037 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 3176 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_colon_rec v lexbuf __ocaml_lex_state\n\nand buffer_gt v lexbuf =\n __ocaml_lex_buffer_gt_rec v lexbuf 503\nand __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 1040 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n# 3188 \"read.ml\"\n\n | 1 ->\n# 1041 \"read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n# 3193 \"read.ml\"\n\n | 2 ->\n# 1042 \"read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 3198 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_buffer_gt_rec v lexbuf __ocaml_lex_state\n\nand finish_buffer_comment v lexbuf =\n __ocaml_lex_finish_buffer_comment_rec v lexbuf 507\nand __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 1045 \"read.mll\"\n ( Bi_outbuf.add_string v.buf \"*/\" )\n# 3210 \"read.ml\"\n\n | 1 ->\n# 1046 \"read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n# 3215 \"read.ml\"\n\n | 2 ->\n# 1047 \"read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n finish_buffer_comment v lexbuf )\n# 3222 \"read.ml\"\n\n | 3 ->\n# 1050 \"read.mll\"\n ( add_lexeme v.buf lexbuf; finish_buffer_comment v lexbuf )\n# 3227 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_finish_buffer_comment_rec v lexbuf __ocaml_lex_state\n\nand junk lexbuf =\n __ocaml_lex_junk_rec lexbuf 513\nand __ocaml_lex_junk_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 1053 \"read.mll\"\n ( Lexing.lexeme lexbuf )\n# 3239 \"read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_junk_rec lexbuf __ocaml_lex_state\n\n;;\n\n# 1055 \"read.mll\"\n \n let _ = (read_json : lexer_state -> Lexing.lexbuf -> json)\n\n let () =\n read_junk := junk\n\n let read_int8 v lexbuf =\n let n = read_int v lexbuf in\n if n < 0 || n > 255 then\n lexer_error \"Int8 overflow\" v lexbuf\n else\n char_of_int n\n\n let read_list read_cell v lexbuf =\n List.rev (read_list_rev read_cell v lexbuf)\n\n let array_of_rev_list l =\n match l with\n [] -> [| |]\n | x :: tl ->\n let len = List.length l in\n let a = Array.make len x in\n let r = ref tl in\n for i = len - 2 downto 0 do\n a.(i) <- List.hd !r;\n r := List.tl !r\n done;\n a\n\n let read_array read_cell v lexbuf =\n let l = read_list_rev read_cell v lexbuf in\n array_of_rev_list l\n\n (* Read a JSON object, reading the keys into OCaml strings\n (provided for backward compatibility) *)\n let read_fields read_field init_acc v =\n read_abstract_fields read_ident read_field init_acc v\n\n let finish v lexbuf =\n read_space v lexbuf;\n if not (read_eof lexbuf) then\n long_error \"Junk after end of JSON value:\" v lexbuf\n\n let init_lexer = init_lexer\n\n let from_lexbuf v ?(stream = false) lexbuf =\n read_space v lexbuf;\n\n let x =\n if read_eof lexbuf then\n raise End_of_input\n else\n read_json v lexbuf\n in\n\n if not stream then\n finish v lexbuf;\n\n x\n\n\n let from_string ?buf ?fname ?lnum s =\n try\n let lexbuf = Lexing.from_string s in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_channel ?buf ?fname ?lnum ic =\n try\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n from_lexbuf v lexbuf\n with End_of_input ->\n json_error \"Blank input data\"\n\n let from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n try\n let x = from_channel ?buf ?fname ?lnum ic in\n close_in ic;\n x\n with e ->\n close_in_noerr ic;\n raise e\n\n let stream_from_lexbuf v ?(fin = fun () -> ()) lexbuf =\n let stream = Some true in\n let f i =\n try Some (from_lexbuf v ?stream lexbuf)\n with\n End_of_input ->\n fin ();\n None\n | e ->\n (try fin () with _ -> ());\n raise e\n in\n Stream.from f\n\n let stream_from_string ?buf ?fname ?lnum s =\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v (Lexing.from_string s)\n\n let stream_from_channel ?buf ?fin ?fname ?lnum ic =\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ?fin lexbuf\n\n let stream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n let lexbuf = Lexing.from_channel ic in\n let v = init_lexer ?buf ?fname ?lnum () in\n stream_from_lexbuf v ~fin lexbuf\n\n type json_line = [ `Json of json | `Exn of exn ]\n\n let linestream_from_channel\n ?buf ?(fin = fun () -> ()) ?fname ?lnum:(lnum0 = 1) ic =\n let buf =\n match buf with\n None -> Some (Bi_outbuf.create 256)\n | Some _ -> buf\n in\n let f i =\n try\n let line = input_line ic in\n let lnum = lnum0 + i in\n Some (`Json (from_string ?buf ?fname ~lnum line))\n with\n End_of_file -> fin (); None\n | e -> Some (`Exn e)\n in\n Stream.from f\n\n let linestream_from_file ?buf ?fname ?lnum file =\n let ic = open_in file in\n let fin () = close_in ic in\n let fname =\n match fname with\n None -> Some file\n | x -> x\n in\n linestream_from_channel ?buf ~fin ?fname ?lnum ic\n\n let prettify ?std s =\n pretty_to_string ?std (from_string s)\n\n let compact ?std s =\n to_string (from_string s)\n\n let validate_json _path _value = None\n\n# 3407 \"read.ml\"\n", "open Format\n\ntype tvar = int * string [@@deriving to_yojson]\n\nlet pp_tvar (fmt : formatter) (tvar : tvar) : unit =\n match tvar with\n | d, \"\" -> fprintf fmt \"'a%d\" d\n | d, l -> fprintf fmt \"'a%d\\\"%s\\\"\" d l\n\ntype evar = int * string [@@deriving to_yojson]\n\nlet pp_evar (fmt : formatter) (evar : evar) : unit =\n match evar with\n | f, \"\" -> fprintf fmt \"F%d\" f\n | f, l -> fprintf fmt \"F%d\\\"%s\\\"\" f l\n\ntype aty =\n | Var of tvar\n | Arrow of t * aty\n\nand t =\n | Lift of aty\n | Inter of t * t\n | Expand of evar * t\n[@@deriving to_yojson]\n\nlet rec pp_aty (fmt : formatter) (aty : aty) : unit =\n match aty with\n | Var a -> pp_tvar fmt a\n | Arrow (ty, aty) -> fprintf fmt \"(%a ->@ %a)\" pp ty pp_aty aty\n\nand pp (fmt : formatter) (ty : t) : unit =\n match ty with\n | Lift aty -> fprintf fmt \"%a\" pp_aty aty\n | Inter (ty1, ty2) -> fprintf fmt \"(%a /\\\\@ %a)\" pp ty1 pp ty2\n | Expand (f, ty) -> fprintf fmt \"(%a %a)\" pp_evar f pp ty\n\nlet tcounter = ref 0\n\nlet fresh_tvar () : tvar =\n incr tcounter; (!tcounter, \"\")\n\nlet ecounter = ref 0\n\nlet fresh_evar () : evar =\n incr ecounter; (!ecounter, \"\")\n\nlet reset_counter () : unit =\n tcounter := 0; ecounter := 0\n\nlet rename_tvar (d, l : tvar) (s : string) : tvar =\n (d, l ^ s)\n\nlet rename_evar (d, l : evar) (s : string) : evar =\n (d, l ^ s)\n\nlet rec rename_vars_aty (aty : aty) (s : string) : aty =\n match aty with\n | Var a -> Var (rename_tvar a s)\n | Arrow (ty, aty) -> Arrow (rename_vars ty s, rename_vars_aty aty s)\n\nand rename_vars (ty : t) (s : string) : t =\n match ty with\n | Lift aty -> Lift (rename_vars_aty aty s)\n | Inter (ty1, ty2) -> Inter (rename_vars ty1 s, rename_vars ty2 s)\n | Expand (f, ty) -> Expand (rename_evar f s, rename_vars ty s)\n\ntype ex =\n | E_Hole\n | E_Inter of ex * ex\n | E_Expand of evar * ex\n[@@deriving to_yojson]\n\nlet rec pp_ex (fmt : formatter) (ex : ex) : unit =\n match ex with\n | E_Hole -> pp_print_string fmt \"[]\"\n | E_Inter (ex1, ex2) -> fprintf fmt \"(%a /\\\\@ %a)\" pp_ex ex1 pp_ex ex2\n | E_Expand (f, ex) -> fprintf fmt \"(%a %a)\" pp_evar f pp_ex ex\n\nlet rec extract_expansion (ty : t) : ex =\n match ty with\n | Lift _ -> E_Hole\n | Inter (ty1, ty2) -> E_Inter (extract_expansion ty1, extract_expansion ty2)\n | Expand (f, ty) -> E_Expand (f, extract_expansion ty)\n\nlet rec expand (ty : t) (ex : ex) : t =\n let rec walk ex s =\n match ex with\n | E_Hole -> rename_vars ty s\n | E_Inter (ex1, ex2) -> Inter (walk ex1 (s ^ \"0\"), walk ex2 (s ^ \"1\"))\n | E_Expand (f, ex) -> Expand (f, walk ex s)\n in\n walk ex \"\"\n\nlet rec replace_tvar_aty (aty : aty) (a : tvar) (aty' : aty) : aty =\n match aty with\n | Var a' -> if a = a' then aty' else aty\n | Arrow (ty, aty) -> Arrow (replace_tvar ty a aty', replace_tvar_aty aty a aty')\n\nand replace_tvar (ty : t) (a : tvar) (aty' : aty) : t =\n match ty with\n | Lift aty -> Lift (replace_tvar_aty aty a aty')\n | Inter (ty1, ty2) -> Inter (replace_tvar ty1 a aty', replace_tvar ty2 a aty')\n | Expand (f, ty) -> Expand (f, replace_tvar ty a aty')\n\nlet rec replace_evar_aty (aty : aty) (f : evar) (ex : ex) : aty =\n match aty with\n | Var _ -> aty\n | Arrow (ty, aty) -> Arrow (replace_evar ty f ex, replace_evar_aty aty f ex)\n\nand replace_evar (ty : t) (f : evar) (ex : ex) : t =\n match ty with\n | Lift aty -> Lift (replace_evar_aty aty f ex)\n | Inter (ty1, ty2) -> Inter (replace_evar ty1 f ex, replace_evar ty2 f ex)\n | Expand (f', ty') -> if f = f' then expand ty' ex else ty\n", "let rec generate (e : Term.t) : Type.aty * Env.t * Constraint.t * Deriv.t =\n match e with\n | Term.Var x ->\n let a = Type.fresh_tvar () in\n let aty = Type.Var a in\n let env = Env.extend Env.empty x (Type.Lift aty) in\n let cstr = [] in\n let skel = Deriv.Var (env, e, aty) in\n (aty, env, cstr, skel)\n | Term.App (e1, e2) ->\n let aty1, env1, cstr1, skel1 = generate e1 in\n let aty2, env2, cstr2, skel2 = generate e2 in\n let a = Type.fresh_tvar () in\n let f = Type.fresh_evar () in\n let aty = Type.Var a in\n let env = Env.(intersect env1 (applyF env2 f)) in\n let cstr = Constraint.(add (union cstr1 (applyF cstr2 f))\n (Type.Lift aty1)\n Type.(Lift (Arrow (Expand (f, Lift aty2), Var a))))\n in\n let skel = Deriv.(App ((env, e, aty), skel1, applyF skel2 f)) in\n (aty, env, cstr, skel)\n | Term.Abs (x, e') ->\n let aty', env', cstr', skel' = generate e' in\n let a = Type.fresh_tvar () in\n begin match Env.lookup env' x with\n | None ->\n let aty = Type.(Arrow (Lift (Var a), aty')) in\n let env = env' in\n let cstr = cstr' in\n let skel = Deriv.(Abs_K ((env, e, aty), skel')) in\n (aty, env, cstr, skel)\n | Some ty_dom ->\n let aty = Type.(Arrow (ty_dom, aty')) in\n let env = Env.remove env' x in\n let cstr = cstr' in\n let skel = Deriv.(Abs_I ((env, e, aty), skel')) in\n (aty, env, cstr, skel)\n end\n\nlet simplify (cstr : Constraint.t) : Constraint.t =\n let rec loop (ty1 : Type.t) (ty2 : Type.t) : Constraint.t =\n match ty1, ty2 with\n | Type.Expand (f1, ty1'), Type.Expand (f2, ty2')\n when f1 = f2 ->\n Constraint.applyF (loop ty1' ty2') f1\n | Type.Lift (Type.Arrow (ty11, aty12)), Type.Lift (Type.Arrow (ty21, aty22)) ->\n Constraint.union (loop ty21 ty11) (loop (Type.Lift aty12) (Type.Lift aty22))\n | Type.Inter (ty11, ty12), Type.Inter (ty21, ty22) ->\n Constraint.union (loop ty11 ty21) (loop ty12 ty22)\n | _ ->\n if ty1 = ty2 then Constraint.empty else Constraint.singleton ty1 ty2\n in\n Constraint.fold cstr Constraint.empty\n (fun ty1 ty2 cstr' -> Constraint.union cstr' (loop ty1 ty2))\n\nlet unify (cstr : Constraint.t) : Subst.t =\n let rec drop_leading_fs ty1 ty2 =\n match ty1, ty2 with\n | Type.Expand (f1, ty1'), Type.Expand (f2, ty2')\n when f1 = f2 ->\n drop_leading_fs ty1' ty2'\n | _ -> (ty1, ty2)\n in\n let rec loop (cstr : Constraint.t) (st : Subst.t) : Subst.t =\n match cstr with\n | [] -> st\n | (ty1, ty2) :: _ ->\n let ty1, ty2 = drop_leading_fs ty1 ty2 in\n let st' = match ty1, ty2 with\n | Type.Lift (Type.Var a), Type.Lift aty ->\n Subst.single_t a aty\n | Type.Lift aty, Type.Lift (Type.Var a) ->\n Subst.single_t a aty\n | Type.Expand (f, ty1), ty2 ->\n Subst.single_e f (Type.extract_expansion ty2)\n | _ ->\n Format.printf \"failed to unify: @[%a@\\n%a@]@\\n\" Type.pp ty1 Type.pp ty2;\n exit 1\n in\n loop (simplify (Constraint.applySubst cstr st')) (Subst.compose st st')\n in\n loop (simplify cstr) (Subst.empty)\n", "open Format\n\ntype replacer =\n | T of Type.tvar * Type.aty\n | E of Type.evar * Type.ex\n[@@deriving to_yojson]\n\ntype t = replacer list [@@deriving to_yojson]\n\nlet pp_replacer (fmt : formatter) (r : replacer) : unit =\n match r with\n | T (a, aty) -> fprintf fmt \"%a := @[%a@]\" Type.pp_tvar a Type.pp_aty aty\n | E (f, ex) -> fprintf fmt \"%a := @[%a@]\" Type.pp_evar f Type.pp_ex ex\n\nlet pp (fmt : formatter) (st : t) : unit =\n fprintf fmt \"{|@[%a@]|}\" (pp_print_list pp_replacer) st\n\nlet empty = []\n\nlet single_t (a : Type.tvar) (aty : Type.aty) : t =\n [T (a, aty)]\n\nlet single_e (f : Type.evar) (ex : Type.ex) : t =\n [E (f, ex)]\n\nlet compose (st1 : t) (st2 : t) : t =\n st1 @ st2\n\nlet apply (st : t) (rt : 'a -> Type.tvar -> Type.aty -> 'a)\n (re : 'a -> Type.evar -> Type.ex -> 'a) (v : 'a) : 'a =\n List.fold_left\n (fun v r ->\n match r with\n | T (a, aty) -> rt v a aty\n | E (f, ex) -> re v f ex)\n v\n st\n\nlet apply_aty (st : t) (aty : Type.aty) : Type.aty =\n apply st Type.replace_tvar_aty Type.replace_evar_aty aty\n\nlet apply_ty (st : t) (ty : Type.t) : Type.t =\n apply st Type.replace_tvar Type.replace_evar ty\n", "open Format\n\ntype t = (Type.t * Type.t) list [@@deriving to_yojson]\n\nlet pp (fmt : formatter) (cstr : t) : unit =\n fprintf fmt \"{@[%a@]}\"\n (pp_print_list\n (fun fmt (ty1, ty2) -> fprintf fmt \"@[%a = %a@]\" Type.pp ty1 Type.pp ty2))\n cstr\n\nlet empty = []\n\nlet singleton (ty1 : Type.t) (ty2 : Type.t) : t =\n [ty1, ty2]\n\nlet add (cstr : t) (ty1 : Type.t) (ty2 : Type.t) : t =\n if List.mem (ty1, ty2) cstr then cstr else (ty1, ty2) :: cstr\n\nlet union (cstr1 : t) (cstr2 : t) : t =\n List.fold_left (fun cstr (ty1, ty2) -> add cstr ty1 ty2) cstr1 cstr2\n\nlet fold (cstr : t) (init : 'a) (f : Type.t -> Type.t -> 'a -> t) : t =\n List.fold_left (fun acc (ty1, ty2) -> f ty1 ty2 acc) init cstr\n\nlet map (cstr : t) (f : Type.t -> Type.t) : t =\n List.map (fun (ty1, ty2) -> (f ty1, f ty2)) cstr\n\nlet applyF (cstr : t) (f : Type.evar) : t =\n map cstr (fun ty -> Type.Expand (f, ty))\n\nlet replace_tvar (cstr : t) (a : Type.tvar) (aty : Type.aty) : t =\n map cstr (fun ty -> Type.replace_tvar ty a aty)\n\nlet replace_evar (cstr : t) (f : Type.evar) (ex : Type.ex) : t =\n map cstr (fun ty -> Type.replace_evar ty f ex)\n\nlet applySubst (cstr : t) (st : Subst.t) : t =\n Subst.apply st replace_tvar replace_evar cstr\n", "open Format\n\ntype var = string (* lambda variable: x *)\n[@@deriving to_yojson]\n\ntype t =\n | Var of var (* lambda variable: x *)\n | App of t * t (* application: e1 e2 *)\n | Abs of var * t (* abstraction: \\x.e *)\n[@@deriving to_yojson]\n\nlet rec pp (fmt : formatter) (e : t) : unit =\n match e with\n | Var x ->\n fprintf fmt \"%s\" x\n | App (e1, e2) ->\n fprintf fmt \"@[(%a@ %a)@]\" pp e1 pp e2\n | Abs (x, e) ->\n fprintf fmt \"@[(fun %s ->@ %a)@]\" x pp e\n", "open Format\n\ntype t = (Term.var * Type.t) list [@@deriving to_yojson]\n\nlet pp (fmt : formatter) (env : t) : unit =\n fprintf fmt \"{@[%a@]}\"\n (pp_print_list (fun fmt (x, ty) -> fprintf fmt \"%s : %a\" x Type.pp ty))\n env\n\n(** An empty environment *)\nlet empty = []\n\n(** [lookup env x] returns an associated type with lambda variable [x]. If no\n such type, this returns [None]. *)\nlet lookup (env : t) (x : Term.var) : Type.t option =\n try Some (List.assoc x env) with Not_found -> None\n\n(** [extend env x t] extends [env] with association [t] to [x]. *)\nlet extend (env : t) (x : Term.var) (ty : Type.t) : t =\n (x, ty) :: env\n\n(** [remove env x] removes all associations concerning [x] from [env], i.e.,\n [lookup (remove env x) x] always returns [None]. *)\nlet remove (env : t) (x : Term.var) : t =\n List.filter (fun (x', _) -> x' <> x) env\n\nlet map_cod (env : t) (f : Type.t -> Type.t) : t =\n List.map (fun (x, ty) -> (x, f ty)) env\n\nlet rename_vars (env : t) (s : string) : t =\n map_cod env (fun ty -> Type.rename_vars ty s)\n\nlet intersect (env1 : t) (env2 : t) : t =\n let env1 = env1 |> List.map (fun (x1, t1) ->\n match lookup env2 x1 with\n | None -> (x1, t1)\n | Some t2 -> (x1, Type.Inter (t1, t2)))\n in\n let env2 = List.fold_left (fun env2 (x1, _) -> remove env2 x1) env2 env1 in\n env1 @ env2\n\nlet applyF (env : t) (f : Type.evar) : t =\n map_cod env (fun ty -> Type.Expand (f, ty))\n\nlet replace_tvar (env : t) (a : Type.tvar) (aty : Type.aty) : t =\n map_cod env (fun ty -> Type.replace_tvar ty a aty)\n\nlet replace_evar (env : t) (f : Type.evar) (ex : Type.ex) : t =\n map_cod env (fun ty -> Type.replace_evar ty f ex)\n\nlet applySubst (env : t) (st : Subst.t) : t =\n Subst.apply st replace_tvar replace_evar env\n", "open Format\n\ntype judge = Env.t * Term.t * Type.aty [@@deriving to_yojson]\n\ntype judge_e = Env.t * Term.t * Type.t [@@deriving to_yojson]\n\ntype t =\n | Var of judge\n | Inter of judge_e * t * t\n | Abs_I of judge * t\n | Abs_K of judge * t\n | App of judge * t * t\n | F of judge_e * t * Type.evar\n[@@deriving to_yojson]\n\nlet pp_judge (fmt : formatter) (env, e, aty : judge) : unit =\n fprintf fmt \"@[%a |-@ %a :@ %a@]\" Env.pp env Term.pp e Type.pp_aty aty\n\nlet pp_judge_e (fmt : formatter) (env, e, ty : judge_e) : unit =\n fprintf fmt \"@[%a |-@ %a :@ %a@]\" Env.pp env Term.pp e Type.pp ty\n\nlet rec pp (fmt : formatter) (skel : t) : unit =\n match skel with\n | Var j ->\n fprintf fmt \"\" pp_judge j\n | Inter (je, skel1, skel2) ->\n fprintf fmt \"%a@,%a@,%a@]>\" pp_judge_e je pp skel1 pp skel2\n | Abs_I (j, skel') ->\n fprintf fmt \"%a@,%a@]>\" pp_judge j pp skel'\n | Abs_K (j, skel') ->\n fprintf fmt \"%a@,%a@]>\" pp_judge j pp skel'\n | App (j, skel1, skel2) ->\n fprintf fmt \"%a@,%a@,%a@]>\" pp_judge j pp skel1 pp skel2\n | F (je, skel', f) ->\n fprintf fmt \"<%a:@[%a@,%a@]>\" Type.pp_evar f pp_judge_e je pp skel'\n\nlet rename_vars_judge (env, e, aty : judge) (s : string) : judge =\n (Env.rename_vars env s, e, Type.rename_vars_aty aty s)\n\nlet rename_vars_judge_e (env, e, ty : judge_e) (s: string) : judge_e =\n (Env.rename_vars env s, e, Type.rename_vars ty s)\n\nlet rec rename_vars (skel : t) (s : string) : t =\n match skel with\n | Var j ->\n Var (rename_vars_judge j s)\n | Inter (je, skel1, skel2) ->\n Inter (rename_vars_judge_e je s, rename_vars skel1 s, rename_vars skel2 s)\n | Abs_I (j, skel) ->\n Abs_I (rename_vars_judge j s, rename_vars skel s)\n | Abs_K (j, skel) ->\n Abs_K (rename_vars_judge j s, rename_vars skel s)\n | App (j, skel1, skel2) ->\n App (rename_vars_judge j s, rename_vars skel1 s, rename_vars skel2 s)\n | F (je, skel, f) ->\n F (rename_vars_judge_e je s, rename_vars skel s, Type.rename_evar f s)\n\nlet intersect (skel1 : t) (skel2 : t) : t =\n match skel1, skel2 with\n | (Var (env1, e1, aty1) | Abs_I ((env1, e1, aty1), _) |\n Abs_K ((env1, e1, aty1), _) | App ((env1, e1, aty1), _, _)),\n (Var (env2, e2, aty2) | Abs_I ((env2, e2, aty2), _) |\n Abs_K ((env2, e2, aty2), _) | App ((env2, e2, aty2), _, _))\n when e1 = e2 ->\n Inter ((Env.intersect env1 env2, e1, Type.(Inter (Lift aty1, Lift aty2))), skel1, skel2)\n | (Inter ((env1, e1, ty1), _, _) | F ((env1, e1, ty1), _, _)),\n (Inter ((env2, e2, ty2), _, _) | F ((env2, e2, ty2), _, _))\n when e1 = e2 ->\n Inter ((Env.intersect env1 env2, e1, Type.Inter (ty1, ty2)), skel1, skel2)\n | (Var (env1, e1, aty1) | Abs_I ((env1, e1, aty1), _) |\n Abs_K ((env1, e1, aty1), _) | App ((env1, e1, aty1), _, _)),\n (Inter ((env2, e2, ty2), _, _) | F ((env2, e2, ty2), _, _))\n when e1 = e2 ->\n Inter ((Env.intersect env1 env2, e1, Type.(Inter (Lift aty1, ty2))), skel1, skel2)\n | (Inter ((env1, e1, ty1), _, _) | F ((env1, e1, ty1), _, _)),\n (Var (env2, e2, aty2) | Abs_I ((env2, e2, aty2), _) |\n Abs_K ((env2, e2, aty2), _) | App ((env2, e2, aty2), _, _))\n when e1 = e2 ->\n Inter ((Env.intersect env1 env2, e1, Type.(Inter (ty1, Lift aty2))), skel1, skel2)\n | _ -> printf \"%a@\\n%a@\\n\" pp skel1 pp skel2; assert false\n\nlet applyF (skel : t) (f : Type.evar) : t =\n match skel with\n | (Var (env, e, aty) | Abs_I ((env, e, aty), _) |\n Abs_K ((env, e, aty), _) | App ((env, e, aty), _, _)) ->\n F ((Env.applyF env f, e, Type.(Expand (f, Lift aty))), skel, f)\n | (Inter ((env, e, ty), _, _) | F ((env, e, ty), _, _)) ->\n F ((Env.applyF env f, e, Type.Expand (f, ty)), skel, f)\n\nlet expand (skel : t) (ex : Type.ex) : t =\n let rec walk ex s =\n match ex with\n | Type.E_Hole -> rename_vars skel s\n | Type.E_Inter (ex1, ex2) -> intersect (walk ex1 (s ^ \"0\")) (walk ex2 (s ^ \"1\"))\n | Type.E_Expand (f, ex) -> applyF (walk ex s) f\n in\n walk ex \"\"\n\nlet replace_tvar_judge (env, e, aty : judge) (a : Type.tvar) (aty' : Type.aty) : judge =\n (Env.replace_tvar env a aty', e, Type.replace_tvar_aty aty a aty')\n\nlet replace_tvar_judge_e (env, e, ty : judge_e) (a : Type.tvar) (aty' : Type.aty) : judge_e =\n (Env.replace_tvar env a aty', e, Type.replace_tvar ty a aty')\n\nlet replace_evar_judge (env, e, aty : judge) (f : Type.evar) (ex : Type.ex) : judge =\n (Env.replace_evar env f ex, e, Type.replace_evar_aty aty f ex)\n\nlet replace_evar_judge_e (env, e, ty: judge_e) (f : Type.evar) (ex : Type.ex) : judge_e =\n (Env.replace_evar env f ex, e, Type.replace_evar ty f ex)\n\nlet rec replace_tvar (skel : t) (a : Type.tvar) (aty : Type.aty) : t =\n let judge x = replace_tvar_judge x a aty in\n let judge_e x = replace_tvar_judge_e x a aty in\n let loop x = replace_tvar x a aty in\n match skel with\n | Var j -> Var (judge j)\n | Inter (je, skel1, skel2) ->\n Inter (judge_e je, loop skel1, loop skel2)\n | Abs_I (j, skel) ->\n Abs_I (judge j, loop skel)\n | Abs_K (j, skel) ->\n Abs_K (judge j, loop skel)\n | App (j, skel1, skel2) ->\n App (judge j, loop skel1, loop skel2)\n | F (je, skel, f) ->\n F (judge_e je, loop skel, f)\n\nlet rec replace_evar (skel : t) (f : Type.evar) (ex : Type.ex) : t =\n let judge x = replace_evar_judge x f ex in\n let judge_e x = replace_evar_judge_e x f ex in\n let loop x = replace_evar x f ex in\n match skel with\n | Var j -> Var (replace_evar_judge j f ex)\n | Inter (je, skel1, skel2) ->\n Inter (judge_e je, loop skel1, loop skel2)\n | Abs_I (j, skel) ->\n Abs_I (judge j, loop skel)\n | Abs_K (j, skel) ->\n Abs_K (judge j, loop skel)\n | App (j, skel1, skel2) ->\n App (judge j, loop skel1, loop skel2)\n | F (je, skel, f') when f = f' ->\n expand skel ex\n | F (je, skel, f) ->\n F (judge_e je, loop skel, f)\n\nlet applySubst (skel : t) (st : Subst.t) : t =\n Subst.apply st replace_tvar replace_evar skel\n", "\nexception Error\n\nlet _eRR =\n Error\n\ntype token = \n | SEMISEMI\n | RPAREN\n | RARROW\n | LPAREN\n | LIDENT of (string)\n | LET\n | FUN\n | DEF\n\ntype _menhir_env = {\n _menhir_lexer: Lexing.lexbuf -> token;\n _menhir_lexbuf: Lexing.lexbuf;\n _menhir_token: token;\n mutable _menhir_error: bool\n}\n\nand _menhir_state = \n | MenhirState16\n | MenhirState9\n | MenhirState7\n | MenhirState4\n | MenhirState3\n | MenhirState1\n | MenhirState0\n \nopen Term\n\nlet rec _menhir_goto_top_phrase : _menhir_env -> 'ttv_tail -> _menhir_state -> (Term.var option * Term.t) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_1 : (Term.var option * Term.t)) = _v in\n Obj.magic _1\n\nand _menhir_goto_expr : _menhir_env -> 'ttv_tail -> _menhir_state -> (Term.t) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState7 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (((_menhir_stack, _menhir_s), _, (params : (Term.var list))), _, (e : (Term.t))) = _menhir_stack in\n let _3 = () in\n let _1 = () in\n let _v : (Term.t) = ( List.fold_right (fun x e -> Abs (x, e)) params e ) in\n _menhir_goto_expr _menhir_env _menhir_stack _menhir_s _v\n | MenhirState1 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RPAREN ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _, (e : (Term.t))) = _menhir_stack in\n let _3 = () in\n let _1 = () in\n let _v : (Term.t) = ( e ) in\n _menhir_goto_a_expr _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState16 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | SEMISEMI ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (((_menhir_stack, _menhir_s), (x : (string))), _, (e : (Term.t))) = _menhir_stack in\n let _5 = () in\n let _3 = () in\n let _1 = () in\n let _v : (Term.var option * Term.t) = ( (Some x, e) ) in\n _menhir_goto_top_phrase _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | MenhirState0 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | SEMISEMI ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (e : (Term.t))) = _menhir_stack in\n let _2 = () in\n let _v : (Term.var option * Term.t) = ( (None, e) ) in\n _menhir_goto_top_phrase _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_fail : unit -> 'a =\n fun () ->\n Printf.fprintf Pervasives.stderr \"Internal failure -- please contact the parser generator's developers.\\n%!\";\n assert false\n\nand _menhir_goto_app_expr : _menhir_env -> 'ttv_tail -> _menhir_state -> (Term.t) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | LIDENT _v ->\n _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState9 _v\n | LPAREN ->\n _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState9\n | RPAREN | SEMISEMI ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (e : (Term.t))) = _menhir_stack in\n let _v : (Term.t) = ( e ) in\n _menhir_goto_expr _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState9\n\nand _menhir_goto_nonempty_list_LIDENT_ : _menhir_env -> 'ttv_tail -> _menhir_state -> (Term.var list) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n match _menhir_s with\n | MenhirState4 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s, (x : (string))), _, (xs : (Term.var list))) = _menhir_stack in\n let _v : (Term.var list) = ( x :: xs ) in\n _menhir_goto_nonempty_list_LIDENT_ _menhir_env _menhir_stack _menhir_s _v\n | MenhirState3 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n assert (not _menhir_env._menhir_error);\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | RARROW ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | FUN ->\n _menhir_run3 _menhir_env (Obj.magic _menhir_stack) MenhirState7\n | LIDENT _v ->\n _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState7 _v\n | LPAREN ->\n _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState7\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState7)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n _menhir_fail ()\n\nand _menhir_goto_a_expr : _menhir_env -> 'ttv_tail -> _menhir_state -> (Term.t) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n match _menhir_s with\n | MenhirState9 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (e2 : (Term.t)) = _v in\n let (_menhir_stack, _menhir_s, (e1 : (Term.t))) = _menhir_stack in\n let _v : (Term.t) = ( App (e1, e2) ) in\n _menhir_goto_app_expr _menhir_env _menhir_stack _menhir_s _v\n | MenhirState0 | MenhirState16 | MenhirState1 | MenhirState7 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (e : (Term.t)) = _v in\n let _v : (Term.t) = ( e ) in\n _menhir_goto_app_expr _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n _menhir_fail ()\n\nand _menhir_run4 : _menhir_env -> 'ttv_tail -> _menhir_state -> (string) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_stack = (_menhir_stack, _menhir_s, _v) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | LIDENT _v ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState4 _v\n | RARROW ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, (x : (string))) = _menhir_stack in\n let _v : (Term.var list) = ( [ x ] ) in\n _menhir_goto_nonempty_list_LIDENT_ _menhir_env _menhir_stack _menhir_s _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState4\n\nand _menhir_errorcase : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n match _menhir_s with\n | MenhirState16 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState9 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState7 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState4 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s, _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState3 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState1 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s\n | MenhirState0 ->\n let _menhir_stack = Obj.magic _menhir_stack in\n raise _eRR\n\nand _menhir_run1 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | FUN ->\n _menhir_run3 _menhir_env (Obj.magic _menhir_stack) MenhirState1\n | LIDENT _v ->\n _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState1 _v\n | LPAREN ->\n _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState1\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState1\n\nand _menhir_run2 : _menhir_env -> 'ttv_tail -> _menhir_state -> (string) -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s _v ->\n let _menhir_env = _menhir_discard _menhir_env in\n let _menhir_stack = Obj.magic _menhir_stack in\n let (x : (string)) = _v in\n let _v : (Term.t) = ( Var x ) in\n _menhir_goto_a_expr _menhir_env _menhir_stack _menhir_s _v\n\nand _menhir_run3 : _menhir_env -> 'ttv_tail -> _menhir_state -> 'ttv_return =\n fun _menhir_env _menhir_stack _menhir_s ->\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | LIDENT _v ->\n _menhir_run4 _menhir_env (Obj.magic _menhir_stack) MenhirState3 _v\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState3\n\nand _menhir_discard : _menhir_env -> _menhir_env =\n fun _menhir_env ->\n let lexer = _menhir_env._menhir_lexer in\n let lexbuf = _menhir_env._menhir_lexbuf in\n let _tok = lexer lexbuf in\n {\n _menhir_lexer = lexer;\n _menhir_lexbuf = lexbuf;\n _menhir_token = _tok;\n _menhir_error = false;\n }\n\nand top_phrase : (Lexing.lexbuf -> token) -> Lexing.lexbuf -> (Term.var option * Term.t) =\n fun lexer lexbuf ->\n let _menhir_env = let _tok = Obj.magic () in\n {\n _menhir_lexer = lexer;\n _menhir_lexbuf = lexbuf;\n _menhir_token = _tok;\n _menhir_error = false;\n } in\n Obj.magic (let _menhir_stack = ((), _menhir_env._menhir_lexbuf.Lexing.lex_curr_p) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n match _tok with\n | FUN ->\n _menhir_run3 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | LET ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_s = MenhirState0 in\n let _menhir_stack = (_menhir_stack, _menhir_s) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | LIDENT _v ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_stack = (_menhir_stack, _v) in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | DEF ->\n let _menhir_stack = Obj.magic _menhir_stack in\n let _menhir_env = _menhir_discard _menhir_env in\n let _tok = _menhir_env._menhir_token in\n (match _tok with\n | FUN ->\n _menhir_run3 _menhir_env (Obj.magic _menhir_stack) MenhirState16\n | LIDENT _v ->\n _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState16 _v\n | LPAREN ->\n _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState16\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState16)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let ((_menhir_stack, _menhir_s), _) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n let _menhir_stack = Obj.magic _menhir_stack in\n let (_menhir_stack, _menhir_s) = _menhir_stack in\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) _menhir_s)\n | LIDENT _v ->\n _menhir_run2 _menhir_env (Obj.magic _menhir_stack) MenhirState0 _v\n | LPAREN ->\n _menhir_run1 _menhir_env (Obj.magic _menhir_stack) MenhirState0\n | _ ->\n assert (not _menhir_env._menhir_error);\n _menhir_env._menhir_error <- true;\n _menhir_errorcase _menhir_env (Obj.magic _menhir_stack) MenhirState0)\n \n\n", "# 1 \"lexer.mll\"\n \n let keywords = [\n (\"let\", Parser.LET);\n (\"fun\", Parser.FUN);\n ]\n\n exception EOF\n\n# 11 \"lexer.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base = \n \"\\000\\000\\084\\000\\001\\000\\000\\000\\000\\000\\252\\255\\253\\255\\254\\255\\\n \\002\\000\\251\\255\\250\\255\\249\\255\";\n Lexing.lex_backtrk = \n \"\\255\\255\\007\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\";\n Lexing.lex_default = \n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\255\\255\\000\\000\\000\\000\\000\\000\";\n Lexing.lex_trans = \n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\008\\000\\008\\000\\008\\000\\008\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\008\\000\\000\\000\\008\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\006\\000\\005\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\004\\000\\002\\000\\011\\000\\009\\000\\010\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\007\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\";\n Lexing.lex_check = \n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\008\\000\\008\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\008\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\000\\000\\002\\000\\004\\000\\003\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\001\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\001\\000\\255\\255\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\";\n Lexing.lex_base_code = \n \"\";\n Lexing.lex_backtrk_code = \n \"\";\n Lexing.lex_default_code = \n \"\";\n Lexing.lex_trans_code = \n \"\";\n Lexing.lex_check_code = \n \"\";\n Lexing.lex_code = \n \"\";\n}\n\nlet rec token lexbuf =\n __ocaml_lex_token_rec lexbuf 0\nand __ocaml_lex_token_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 11 \"lexer.mll\"\n ( token lexbuf )\n# 131 \"lexer.ml\"\n\n | 1 ->\n# 12 \"lexer.mll\"\n ( raise EOF )\n# 136 \"lexer.ml\"\n\n | 2 ->\n# 13 \"lexer.mll\"\n ( Parser.LPAREN )\n# 141 \"lexer.ml\"\n\n | 3 ->\n# 14 \"lexer.mll\"\n ( Parser.RPAREN )\n# 146 \"lexer.ml\"\n\n | 4 ->\n# 15 \"lexer.mll\"\n ( Parser.DEF )\n# 151 \"lexer.ml\"\n\n | 5 ->\n# 16 \"lexer.mll\"\n ( Parser.RARROW )\n# 156 \"lexer.ml\"\n\n | 6 ->\n# 17 \"lexer.mll\"\n ( Parser.SEMISEMI )\n# 161 \"lexer.ml\"\n\n | 7 ->\nlet\n# 18 \"lexer.mll\"\n id\n# 167 \"lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 19 \"lexer.mll\"\n ( try List.assoc id keywords with Not_found -> Parser.LIDENT id )\n# 171 \"lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; \n __ocaml_lex_token_rec lexbuf __ocaml_lex_state\n\n;;\n\n", "{\n let keywords = [\n (\"let\", Parser.LET);\n (\"fun\", Parser.FUN);\n ]\n\n exception EOF\n}\n\nrule token = parse\n [' ' '\\t' '\\n']+ { token lexbuf }\n | eof { raise EOF }\n | '(' { Parser.LPAREN }\n | ')' { Parser.RPAREN }\n | \":=\" { Parser.DEF }\n | \"->\" { Parser.RARROW }\n | \";;\" { Parser.SEMISEMI }\n | ['a'-'z'] [''' '_' 'a'-'z' 'A'-'Z' '0'-'9']* as id\n { try List.assoc id keywords with Not_found -> Parser.LIDENT id }\n", "type skel_ret =\n | S_Error of string\n | S_Succ of Constraint.t * Deriv.t\n[@@deriving to_yojson]\n\ntype infer_ret =\n | I_Error of string\n | I_Succ of Type.aty * Subst.t * Deriv.t\n[@@deriving to_yojson]\n\nlet _ =\n Js.export_all\n (object%js\n method skel (s : Js.js_string Js.t) : Js.js_string Js.t =\n Type.reset_counter ();\n let lexbuf = Lexing.from_string (Js.to_string s) in\n let ret = try\n let _, e = Parser.top_phrase Lexer.token lexbuf in\n let _, _, cstr, skel = Inference.generate e in\n S_Succ (cstr, skel)\n with\n | _ ->\n S_Error \"parse error\"\n in\n skel_ret_to_yojson ret |> Yojson.Safe.to_string ~std:true |> Js.string\n\n method infer (s : Js.js_string Js.t) : Js.js_string Js.t =\n Type.reset_counter ();\n let lexbuf = Lexing.from_string (Js.to_string s) in\n let ret = try\n let _, e = Parser.top_phrase Lexer.token lexbuf in\n let aty, _, cstr, skel = Inference.generate e in\n let st = Inference.unify cstr in\n let deriv = Deriv.applySubst skel st in\n I_Succ (Subst.apply_aty st aty, st, deriv)\n with\n | _ ->\n I_Error \"fatal error\"\n in\n infer_ret_to_yojson ret |> Yojson.Safe.to_string ~std:true |> Js.string\n end)\n", "(***********************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1996 Institut National de Recherche en Informatique et *)\n(* en Automatique. All rights reserved. This file is distributed *)\n(* under the terms of the GNU Library General Public License, with *)\n(* the special exception on linking described in file ../LICENSE. *)\n(* *)\n(***********************************************************************)\n\n(* Ensure that [at_exit] functions are called at the end of every program *)\n\nlet _ = do_at_exit()\n"]}