From 17c5f629c9d4e93f6b21c80add5c5f4526ff316d Mon Sep 17 00:00:00 2001
From: Thomas Wood <thomas.wood09@imperial.ac.uk>
Date: Fri, 18 Sep 2015 19:46:54 +0100
Subject: [PATCH] Freeze jsref .ml files.

---
 convert-ml-strings.pl                        |    3 +-
 generator/Makefile                           |   21 +-
 generator/tests/jsref/Ascii.ml               |    0
 generator/tests/jsref/BinInt.ml              | 1020 +++
 generator/tests/jsref/BinNat.ml              |  738 ++
 generator/tests/jsref/BinNums.ml             |    0
 generator/tests/jsref/BinPos.ml              | 1060 +++
 generator/tests/jsref/BinPosDef.ml           |  923 +++
 generator/tests/jsref/Bool0.ml               |   16 +
 generator/tests/jsref/Datatypes.ml           |   43 +
 generator/tests/jsref/Fappli_IEEE.ml         |    0
 generator/tests/jsref/Fappli_IEEE_bits.ml    |    2 +
 generator/tests/jsref/JsCommon.ml            |  596 ++
 generator/tests/jsref/JsCommonAux.ml         |  413 ++
 generator/tests/jsref/JsInit.ml              | 1345 ++++
 generator/tests/jsref/JsInterpreter.ml       | 6189 ++++++++++++++++
 generator/tests/jsref/JsInterpreterMonads.ml |  460 ++
 generator/tests/jsref/JsNumber.ml            |  191 +
 generator/tests/jsref/JsPreliminary.ml       |  228 +
 generator/tests/jsref/JsSyntax.ml            |  681 ++
 generator/tests/jsref/JsSyntaxAux.ml         | 6842 ++++++++++++++++++
 generator/tests/jsref/JsSyntaxInfos.ml       |  121 +
 generator/tests/jsref/LibBool.ml             |   16 +
 generator/tests/jsref/LibFunc.ml             |    5 +
 generator/tests/jsref/LibHeap.ml             |   95 +
 generator/tests/jsref/LibInt.ml              |   39 +
 generator/tests/jsref/LibList.ml             |   95 +
 generator/tests/jsref/LibLogic.ml            |    3 +
 generator/tests/jsref/LibNat.ml              |   27 +
 generator/tests/jsref/LibOperation.ml        |    2 +
 generator/tests/jsref/LibOption.ml           |   34 +
 generator/tests/jsref/LibProd.ml             |   15 +
 generator/tests/jsref/LibReflect.ml          |   56 +
 generator/tests/jsref/LibStream.ml           |    4 +
 generator/tests/jsref/LibString.ml           |    8 +
 generator/tests/jsref/LibTactics.ml          |    5 +
 generator/tests/jsref/List0.ml               |   20 +
 generator/tests/jsref/Peano.ml               |   14 +
 generator/tests/jsref/Shared.ml              |   87 +
 generator/tests/jsref/Specif.ml              |    4 +
 generator/tests/jsref/String0.ml             |   48 +
 41 files changed, 21462 insertions(+), 7 deletions(-)
 create mode 100644 generator/tests/jsref/Ascii.ml
 create mode 100644 generator/tests/jsref/BinInt.ml
 create mode 100644 generator/tests/jsref/BinNat.ml
 create mode 100644 generator/tests/jsref/BinNums.ml
 create mode 100644 generator/tests/jsref/BinPos.ml
 create mode 100644 generator/tests/jsref/BinPosDef.ml
 create mode 100644 generator/tests/jsref/Bool0.ml
 create mode 100644 generator/tests/jsref/Datatypes.ml
 create mode 100644 generator/tests/jsref/Fappli_IEEE.ml
 create mode 100644 generator/tests/jsref/Fappli_IEEE_bits.ml
 create mode 100644 generator/tests/jsref/JsCommon.ml
 create mode 100644 generator/tests/jsref/JsCommonAux.ml
 create mode 100644 generator/tests/jsref/JsInit.ml
 create mode 100644 generator/tests/jsref/JsInterpreter.ml
 create mode 100644 generator/tests/jsref/JsInterpreterMonads.ml
 create mode 100644 generator/tests/jsref/JsNumber.ml
 create mode 100644 generator/tests/jsref/JsPreliminary.ml
 create mode 100644 generator/tests/jsref/JsSyntax.ml
 create mode 100644 generator/tests/jsref/JsSyntaxAux.ml
 create mode 100644 generator/tests/jsref/JsSyntaxInfos.ml
 create mode 100644 generator/tests/jsref/LibBool.ml
 create mode 100644 generator/tests/jsref/LibFunc.ml
 create mode 100644 generator/tests/jsref/LibHeap.ml
 create mode 100644 generator/tests/jsref/LibInt.ml
 create mode 100644 generator/tests/jsref/LibList.ml
 create mode 100644 generator/tests/jsref/LibLogic.ml
 create mode 100644 generator/tests/jsref/LibNat.ml
 create mode 100644 generator/tests/jsref/LibOperation.ml
 create mode 100644 generator/tests/jsref/LibOption.ml
 create mode 100644 generator/tests/jsref/LibProd.ml
 create mode 100644 generator/tests/jsref/LibReflect.ml
 create mode 100644 generator/tests/jsref/LibStream.ml
 create mode 100644 generator/tests/jsref/LibString.ml
 create mode 100644 generator/tests/jsref/LibTactics.ml
 create mode 100644 generator/tests/jsref/List0.ml
 create mode 100644 generator/tests/jsref/Peano.ml
 create mode 100644 generator/tests/jsref/Shared.ml
 create mode 100644 generator/tests/jsref/Specif.ml
 create mode 100644 generator/tests/jsref/String0.ml

diff --git a/convert-ml-strings.pl b/convert-ml-strings.pl
index 6bba4d9..4fdfbf0 100755
--- a/convert-ml-strings.pl
+++ b/convert-ml-strings.pl
@@ -1,4 +1,4 @@
-#!/usr/bin/perl -p
+#!/usr/bin/perl -p -i
 # Converts ml char-array constructions into strings
 # eg: ('a'::('b'::('c'::[]))) => "abc"
 #
@@ -9,6 +9,7 @@
 # substituted for \") onto the result of the previous execution of this expression.
 # $^R isn't cleared between regular expression matches, so we do this manually.
 # The -p operator to Perl wraps this script in a foreach loop that operates over a given file.
+# The -i operator to Perl modifies the file in-place, unfortunately this cannot be passed to the script from the shell
 
 $^R = "";
 s/'([^']|\\(?:\\|"|'|n|r|t|b| |\d{3}|x[0-9a-fA-F]{2}))(?{ $^R.($^N =~ s{^"}{\\"}r) })'::(?:\((?R)\)|\[\])/"$^R"/;
diff --git a/generator/Makefile b/generator/Makefile
index 2a1fe8e..dbec9b3 100644
--- a/generator/Makefile
+++ b/generator/Makefile
@@ -2,14 +2,11 @@
 
 # requires: opam switch 4.02.1; eval `opam config env`
 
-
-# OCAMLBIN=~/shared/ocamleasy/bin/
-# OCAMLLIB=~/shared/ocamleasy/lib
-
 STD_DIR	    := stdlib_ml
 TEST_DIR    := tests
 ML_TESTS    := $(wildcard $(TEST_DIR)/*.ml)
 ML_LAMBDA   := $(wildcard $(TEST_DIR)/lambda/*.ml)
+ML_JSREF    := $(wildcard $(TEST_DIR)/jsref/*.ml)
 
 OCAMLBUILD  := ocamlbuild -j 4 -classic-display -use-ocamlfind
 
@@ -40,8 +37,15 @@ stdlib:
 tests/%.ml: tests/%.v
 	$(MAKE) -C $(CURDIR)/../../../lib/tlc/src
 	cd $(<D) && coqc -I $(CURDIR)/../../../lib/tlc/src $(<F)
-	cd $(<D) && rm *.mli
-	cd $(<D) && $(CURDIR)/../../ml-add-cstr-annots.pl *.ml
+	cd $(@D) && rm *.mli
+	cd $(@D) && $(CURDIR)/../../ml-add-cstr-annots.pl *.ml
+
+.PRECIOUS: tests/jsref/%.ml
+tests/jsref/%.ml:
+	$(MAKE) -C $(CURDIR)/../../.. interpreter
+	cp ../../../interp/src/extract/*.ml tests/jsref/
+	../../convert-ml-strings.pl tests/jsref/*.ml
+	cd $(@D) && $(CURDIR)/../../ml-add-cstr-annots.pl *.ml
 
 tests/%.ml.d: tests/%.ml
 	$(OCAMLDEP) -I $(<D) $< | $(DEPSED) > $@
@@ -52,6 +56,7 @@ tests/%.cmi tests/%.log.js tests/%.unlog.js: tests/%.ml main.byte stdlib
 tests: $(ML_TESTS:.ml=.log.js)
 
 tests/lambda: tests/lambda/Lambda.log.js
+tests/jsref: tests/jsref/JsInterpreter.log.js
 
 clean_stdlib:
 	rm -f $(STD_DIR)/*.cmi
@@ -75,3 +80,7 @@ endif
 ifeq ($(MAKECMDGOALS),tests/lambda)
 -include $(ML_LAMBDA:.ml=.ml.d)
 endif
+
+ifeq ($(MAKECMDGOALS),tests/jsref)
+-include $(ML_JSREF:.ml=.ml.d)
+endif
diff --git a/generator/tests/jsref/Ascii.ml b/generator/tests/jsref/Ascii.ml
new file mode 100644
index 0000000..e69de29
diff --git a/generator/tests/jsref/BinInt.ml b/generator/tests/jsref/BinInt.ml
new file mode 100644
index 0000000..0b89fa5
--- /dev/null
+++ b/generator/tests/jsref/BinInt.ml
@@ -0,0 +1,1020 @@
+open BinNat
+open BinPos
+open Bool0
+open Datatypes
+
+type __ = Obj.t
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
+module Z = 
+ struct 
+  type t = float
+  
+  (** val zero : float **)
+  
+  let zero =
+    0.
+  
+  (** val one : float **)
+  
+  let one =
+    1.
+  
+  (** val two : float **)
+  
+  let two =
+    ((fun p -> 2. *. p) 1.)
+  
+  (** val double : float -> float **)
+  
+  let double x =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun p -> ((fun p -> 2. *. p)
+      p))
+      (fun p -> (~-.) ((fun p -> 2. *. p)
+      p))
+      x
+  
+  (** val succ_double : float -> float **)
+  
+  let succ_double x =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      1.)
+      (fun p -> ((fun p -> 1. +. (2. *. p))
+      p))
+      (fun p -> (~-.)
+      (Pos.pred_double p))
+      x
+  
+  (** val pred_double : float -> float **)
+  
+  let pred_double x =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ -> (~-.)
+      1.)
+      (fun p ->
+      (Pos.pred_double p))
+      (fun p -> (~-.) ((fun p -> 1. +. (2. *. p))
+      p))
+      x
+  
+  (** val pos_sub : float -> float -> float **)
+  
+  let rec pos_sub x y =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        double (pos_sub p q))
+        (fun q ->
+        succ_double (pos_sub p q))
+        (fun _ -> ((fun p -> 2. *. p)
+        p))
+        y)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        pred_double (pos_sub p q))
+        (fun q ->
+        double (pos_sub p q))
+        (fun _ ->
+        (Pos.pred_double p))
+        y)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q -> (~-.) ((fun p -> 2. *. p)
+        q))
+        (fun q -> (~-.)
+        (Pos.pred_double q))
+        (fun _ ->
+        0.)
+        y)
+      x
+  
+  (** val add : float -> float -> float **)
+  
+  let add = (+.)
+  
+  (** val opp : float -> float **)
+  
+  let opp = (~-.)
+  
+  (** val succ : float -> float **)
+  
+  let succ = (+.) 1.
+  
+  (** val pred : float -> float **)
+  
+  let pred = (fun x -> x -. 1.)
+  
+  (** val sub : float -> float -> float **)
+  
+  let sub = (-.)
+  
+  (** val mul : float -> float -> float **)
+  
+  let mul = ( *. )
+  
+  (** val pow_pos : float -> float -> float **)
+  
+  let pow_pos z n =
+    Pos.iter n (mul z) 1.
+  
+  (** val pow : float -> float -> float **)
+  
+  let pow x y =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      1.)
+      (fun p ->
+      pow_pos x p)
+      (fun p ->
+      0.)
+      y
+  
+  (** val square : float -> float **)
+  
+  let square x =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun p ->
+      (Pos.square p))
+      (fun p ->
+      (Pos.square p))
+      x
+  
+  (** val compare : float -> float -> comparison **)
+  
+  let compare = fun x y -> if x=y then Eq else if x<y then Lt else Gt
+  
+  (** val sgn : float -> float **)
+  
+  let sgn z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun p ->
+      1.)
+      (fun p -> (~-.)
+      1.)
+      z
+  
+  (** val leb : float -> float -> bool **)
+  
+  let leb x y =
+    match compare x y with
+    | Eq -> true
+    | Lt -> true
+    | Gt -> false
+  
+  (** val ltb : float -> float -> bool **)
+  
+  let ltb x y =
+    match compare x y with
+    | Eq -> false
+    | Lt -> true
+    | Gt -> false
+  
+  (** val geb : float -> float -> bool **)
+  
+  let geb x y =
+    match compare x y with
+    | Eq -> true
+    | Lt -> false
+    | Gt -> true
+  
+  (** val gtb : float -> float -> bool **)
+  
+  let gtb x y =
+    match compare x y with
+    | Eq -> false
+    | Lt -> false
+    | Gt -> true
+  
+  (** val eqb : float -> float -> bool **)
+  
+  let rec eqb x y =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        true)
+        (fun p ->
+        false)
+        (fun p ->
+        false)
+        y)
+      (fun p ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        false)
+        (fun q ->
+        Pos.eqb p q)
+        (fun p0 ->
+        false)
+        y)
+      (fun p ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        false)
+        (fun p0 ->
+        false)
+        (fun q ->
+        Pos.eqb p q)
+        y)
+      x
+  
+  (** val max : float -> float -> float **)
+  
+  let max = max
+  
+  (** val min : float -> float -> float **)
+  
+  let min = min
+  
+  (** val abs : float -> float **)
+  
+  let abs = abs_float
+  
+  (** val abs_nat : float -> int **)
+  
+  let abs_nat z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0)
+      (fun p ->
+      Pos.to_nat p)
+      (fun p ->
+      Pos.to_nat p)
+      z
+  
+  (** val abs_N : float -> float **)
+  
+  let abs_N z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun p ->
+      p)
+      (fun p ->
+      p)
+      z
+  
+  (** val to_nat : float -> int **)
+  
+  let to_nat z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0)
+      (fun p ->
+      Pos.to_nat p)
+      (fun p ->
+      0)
+      z
+  
+  (** val to_N : float -> float **)
+  
+  let to_N z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun p ->
+      p)
+      (fun p ->
+      0.)
+      z
+  
+  (** val of_nat : int -> float **)
+  
+  let of_nat n =
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      0.)
+      (fun n0 ->
+      (Pos.of_succ_nat n0))
+      n
+  
+  (** val of_N : float -> float **)
+  
+  let of_N n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p ->
+      p)
+      n
+  
+  (** val to_pos : float -> float **)
+  
+  let to_pos z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      1.)
+      (fun p ->
+      p)
+      (fun p ->
+      1.)
+      z
+  
+  (** val iter : float -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
+  
+  let iter n f x =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      x)
+      (fun p ->
+      Pos.iter p f x)
+      (fun p ->
+      x)
+      n
+  
+  (** val pos_div_eucl : float -> float -> float * float **)
+  
+  let rec pos_div_eucl a b =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun a' ->
+      let (q, r) = pos_div_eucl a' b in
+      let r' = add (mul ((fun p -> 2. *. p) 1.) r) 1. in
+      if ltb r' b
+      then ((mul ((fun p -> 2. *. p) 1.) q), r')
+      else ((add (mul ((fun p -> 2. *. p) 1.) q) 1.), (sub r' b)))
+      (fun a' ->
+      let (q, r) = pos_div_eucl a' b in
+      let r' = mul ((fun p -> 2. *. p) 1.) r in
+      if ltb r' b
+      then ((mul ((fun p -> 2. *. p) 1.) q), r')
+      else ((add (mul ((fun p -> 2. *. p) 1.) q) 1.), (sub r' b)))
+      (fun _ ->
+      if leb ((fun p -> 2. *. p) 1.) b then (0., 1.) else (1., 0.))
+      a
+  
+  (** val div_eucl : float -> float -> float * float **)
+  
+  let div_eucl a b =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ -> (0.,
+      0.))
+      (fun a' ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ -> (0.,
+        0.))
+        (fun p ->
+        pos_div_eucl a' b)
+        (fun b' ->
+        let (q, r) = pos_div_eucl a' b' in
+        ((fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+           (fun _ -> ((opp q),
+           0.))
+           (fun p -> ((opp (add q 1.)),
+           (add b r)))
+           (fun p -> ((opp (add q 1.)),
+           (add b r)))
+           r))
+        b)
+      (fun a' ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ -> (0.,
+        0.))
+        (fun p ->
+        let (q, r) = pos_div_eucl a' b in
+        ((fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+           (fun _ -> ((opp q),
+           0.))
+           (fun p0 -> ((opp (add q 1.)),
+           (sub b r)))
+           (fun p0 -> ((opp (add q 1.)),
+           (sub b r)))
+           r))
+        (fun b' ->
+        let (q, r) = pos_div_eucl a' b' in (q, (opp r)))
+        b)
+      a
+  
+  (** val div : float -> float -> float **)
+  
+  let div a b =
+    let (q, x) = div_eucl a b in q
+  
+  (** val modulo : float -> float -> float **)
+  
+  let modulo a b =
+    let (x, r) = div_eucl a b in r
+  
+  (** val quotrem : float -> float -> float * float **)
+  
+  let quotrem a b =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ -> (0.,
+      0.))
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ -> (0.,
+        a))
+        (fun b0 ->
+        let (q, r) = N.pos_div_eucl a0 b0 in ((of_N q), (of_N r)))
+        (fun b0 ->
+        let (q, r) = N.pos_div_eucl a0 b0 in ((opp (of_N q)), (of_N r)))
+        b)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ -> (0.,
+        a))
+        (fun b0 ->
+        let (q, r) = N.pos_div_eucl a0 b0 in ((opp (of_N q)), (opp (of_N r))))
+        (fun b0 ->
+        let (q, r) = N.pos_div_eucl a0 b0 in ((of_N q), (opp (of_N r))))
+        b)
+      a
+  
+  (** val quot : float -> float -> float **)
+  
+  let quot a b =
+    fst (quotrem a b)
+  
+  (** val rem : float -> float -> float **)
+  
+  let rem a b =
+    snd (quotrem a b)
+  
+  (** val even : float -> bool **)
+  
+  let even z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      true)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        false)
+        (fun p0 ->
+        true)
+        (fun _ ->
+        false)
+        p)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        false)
+        (fun p0 ->
+        true)
+        (fun _ ->
+        false)
+        p)
+      z
+  
+  (** val odd : float -> bool **)
+  
+  let odd z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      false)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        true)
+        (fun p0 ->
+        false)
+        (fun _ ->
+        true)
+        p)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        true)
+        (fun p0 ->
+        false)
+        (fun _ ->
+        true)
+        p)
+      z
+  
+  (** val div2 : float -> float **)
+  
+  let div2 z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        (Pos.div2 p))
+        (fun p0 ->
+        (Pos.div2 p))
+        (fun _ ->
+        0.)
+        p)
+      (fun p -> (~-.)
+      (Pos.div2_up p))
+      z
+  
+  (** val quot2 : float -> float **)
+  
+  let quot2 z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        (Pos.div2 p))
+        (fun p0 ->
+        (Pos.div2 p))
+        (fun _ ->
+        0.)
+        p)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 -> (~-.)
+        (Pos.div2 p))
+        (fun p0 -> (~-.)
+        (Pos.div2 p))
+        (fun _ ->
+        0.)
+        p)
+      z
+  
+  (** val log2 : float -> float **)
+  
+  let log2 z =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p ->
+        (Pos.size p))
+        (fun p ->
+        (Pos.size p))
+        (fun _ ->
+        0.)
+        p0)
+      (fun p ->
+      0.)
+      z
+  
+  (** val sqrtrem : float -> float * float **)
+  
+  let sqrtrem n =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ -> (0.,
+      0.))
+      (fun p ->
+      let (s, m) = Pos.sqrtrem p in
+      (match m with
+       | Pos.IsNul -> (s, 0.)
+       | Pos.IsPos r -> (s, r)
+       | Pos.IsNeg -> (s, 0.)))
+      (fun p -> (0.,
+      0.))
+      n
+  
+  (** val sqrt : float -> float **)
+  
+  let sqrt n =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun p ->
+      (Pos.sqrt p))
+      (fun p ->
+      0.)
+      n
+  
+  (** val gcd : float -> float -> float **)
+  
+  let gcd a b =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      abs b)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        abs a)
+        (fun b0 ->
+        (Pos.gcd a0 b0))
+        (fun b0 ->
+        (Pos.gcd a0 b0))
+        b)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        abs a)
+        (fun b0 ->
+        (Pos.gcd a0 b0))
+        (fun b0 ->
+        (Pos.gcd a0 b0))
+        b)
+      a
+  
+  (** val ggcd : float -> float -> float * (float * float) **)
+  
+  let ggcd a b =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ -> ((abs b), (0.,
+      (sgn b))))
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ -> ((abs a), ((sgn a),
+        0.)))
+        (fun b0 ->
+        let (g, p) = Pos.ggcd a0 b0 in let (aa, bb) = p in (g, (aa, bb)))
+        (fun b0 ->
+        let (g, p) = Pos.ggcd a0 b0 in
+        let (aa, bb) = p in (g, (aa, ((~-.) bb))))
+        b)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ -> ((abs a), ((sgn a),
+        0.)))
+        (fun b0 ->
+        let (g, p) = Pos.ggcd a0 b0 in
+        let (aa, bb) = p in (g, (((~-.) aa), bb)))
+        (fun b0 ->
+        let (g, p) = Pos.ggcd a0 b0 in
+        let (aa, bb) = p in (g, (((~-.) aa), ((~-.) bb))))
+        b)
+      a
+  
+  (** val testbit : float -> float -> bool **)
+  
+  let testbit a n =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      odd a)
+      (fun p ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        false)
+        (fun a0 ->
+        Pos.testbit a0 p)
+        (fun a0 ->
+        negb (N.testbit (Pos.pred_N a0) p))
+        a)
+      (fun p ->
+      false)
+      n
+  
+  (** val shiftl : float -> float -> float **)
+  
+  let shiftl a n =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      a)
+      (fun p ->
+      Pos.iter p (mul ((fun p -> 2. *. p) 1.)) a)
+      (fun p ->
+      Pos.iter p div2 a)
+      n
+  
+  (** val shiftr : float -> float -> float **)
+  
+  let shiftr a n =
+    shiftl a (opp n)
+  
+  (** val coq_lor : float -> float -> float **)
+  
+  let coq_lor a b =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      b)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        a)
+        (fun b0 ->
+        (Pos.coq_lor a0 b0))
+        (fun b0 -> (~-.)
+        (N.succ_pos (N.ldiff (Pos.pred_N b0) a0)))
+        b)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        a)
+        (fun b0 -> (~-.)
+        (N.succ_pos (N.ldiff (Pos.pred_N a0) b0)))
+        (fun b0 -> (~-.)
+        (N.succ_pos (N.coq_land (Pos.pred_N a0) (Pos.pred_N b0))))
+        b)
+      a
+  
+  (** val coq_land : float -> float -> float **)
+  
+  let coq_land a b =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        0.)
+        (fun b0 ->
+        of_N (Pos.coq_land a0 b0))
+        (fun b0 ->
+        of_N (N.ldiff a0 (Pos.pred_N b0)))
+        b)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        0.)
+        (fun b0 ->
+        of_N (N.ldiff b0 (Pos.pred_N a0)))
+        (fun b0 -> (~-.)
+        (N.succ_pos (N.coq_lor (Pos.pred_N a0) (Pos.pred_N b0))))
+        b)
+      a
+  
+  (** val ldiff : float -> float -> float **)
+  
+  let ldiff a b =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      0.)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        a)
+        (fun b0 ->
+        of_N (Pos.ldiff a0 b0))
+        (fun b0 ->
+        of_N (N.coq_land a0 (Pos.pred_N b0)))
+        b)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        a)
+        (fun b0 -> (~-.)
+        (N.succ_pos (N.coq_lor (Pos.pred_N a0) b0)))
+        (fun b0 ->
+        of_N (N.ldiff (Pos.pred_N b0) (Pos.pred_N a0)))
+        b)
+      a
+  
+  (** val coq_lxor : float -> float -> float **)
+  
+  let coq_lxor a b =
+    (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+      (fun _ ->
+      b)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        a)
+        (fun b0 ->
+        of_N (Pos.coq_lxor a0 b0))
+        (fun b0 -> (~-.)
+        (N.succ_pos (N.coq_lxor a0 (Pos.pred_N b0))))
+        b)
+      (fun a0 ->
+      (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+        (fun _ ->
+        a)
+        (fun b0 -> (~-.)
+        (N.succ_pos (N.coq_lxor (Pos.pred_N a0) b0)))
+        (fun b0 ->
+        of_N (N.coq_lxor (Pos.pred_N a0) (Pos.pred_N b0)))
+        b)
+      a
+  
+  (** val eq_dec : float -> float -> bool **)
+  
+  let eq_dec x y =
+    ((fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+       (fun _ y0 ->
+       (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+         (fun _ ->
+         true)
+         (fun p ->
+         false)
+         (fun p ->
+         false)
+         y0)
+       (fun x0 y0 ->
+       (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+         (fun _ ->
+         false)
+         (fun p0 ->
+         if Pos.eq_dec x0 p0 then true else false)
+         (fun p0 ->
+         false)
+         y0)
+       (fun x0 y0 ->
+       (fun f0 fp fn z -> if z=0. then f0 () else if z>0. then fp z else fn (~-. z))
+         (fun _ ->
+         false)
+         (fun p0 ->
+         false)
+         (fun p0 ->
+         if Pos.eq_dec x0 p0 then true else false)
+         y0)
+       x) y
+  
+  module Private_BootStrap = 
+   struct 
+    
+   end
+  
+  (** val leb_spec0 : float -> float -> reflect **)
+  
+  let leb_spec0 x y =
+    iff_reflect (leb x y)
+  
+  (** val ltb_spec0 : float -> float -> reflect **)
+  
+  let ltb_spec0 x y =
+    iff_reflect (ltb x y)
+  
+  module Private_OrderTac = 
+   struct 
+    module IsTotal = 
+     struct 
+      
+     end
+    
+    module Tac = 
+     struct 
+      
+     end
+   end
+  
+  (** val sqrt_up : float -> float **)
+  
+  let sqrt_up a =
+    match compare 0. a with
+    | Eq -> 0.
+    | Lt -> succ (sqrt (pred a))
+    | Gt -> 0.
+  
+  (** val log2_up : float -> float **)
+  
+  let log2_up a =
+    match compare 1. a with
+    | Eq -> 0.
+    | Lt -> succ (log2 (pred a))
+    | Gt -> 0.
+  
+  module Private_NZDiv = 
+   struct 
+    
+   end
+  
+  module Private_Div = 
+   struct 
+    module Quot2Div = 
+     struct 
+      (** val div : float -> float -> float **)
+      
+      let div =
+        quot
+      
+      (** val modulo : float -> float -> float **)
+      
+      let modulo =
+        rem
+     end
+    
+    module NZQuot = 
+     struct 
+      
+     end
+   end
+  
+  (** val lcm : float -> float -> float **)
+  
+  let lcm a b =
+    abs (mul a (div b (gcd a b)))
+  
+  (** val eqb_spec : float -> float -> reflect **)
+  
+  let eqb_spec x y =
+    iff_reflect (eqb x y)
+  
+  (** val b2z : bool -> float **)
+  
+  let b2z = function
+  | true -> 1.
+  | false -> 0.
+  
+  (** val setbit : float -> float -> float **)
+  
+  let setbit a n =
+    coq_lor a (shiftl 1. n)
+  
+  (** val clearbit : float -> float -> float **)
+  
+  let clearbit a n =
+    ldiff a (shiftl 1. n)
+  
+  (** val lnot : float -> float **)
+  
+  let lnot a =
+    pred (opp a)
+  
+  (** val ones : float -> float **)
+  
+  let ones n =
+    pred (shiftl 1. n)
+  
+  module Private_Tac = 
+   struct 
+    
+   end
+  
+  module Private_Dec = 
+   struct 
+    (** val max_case_strong :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> (__ -> 'a1)
+        -> (__ -> 'a1) -> 'a1 **)
+    
+    let max_case_strong n m compat hl hr =
+      let c = coq_CompSpec2Type n m (compare n m) in
+      (match c with
+       | CompEqT -> compat m (max n m) __ (hr __)
+       | CompLtT -> compat m (max n m) __ (hr __)
+       | CompGtT -> compat n (max n m) __ (hl __))
+    
+    (** val max_case :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1
+        -> 'a1 **)
+    
+    let max_case n m x x0 x1 =
+      max_case_strong n m x (fun _ -> x0) (fun _ -> x1)
+    
+    (** val max_dec : float -> float -> bool **)
+    
+    let max_dec n m =
+      max_case n m (fun x y _ h0 -> if h0 then true else false) true false
+    
+    (** val min_case_strong :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> (__ -> 'a1)
+        -> (__ -> 'a1) -> 'a1 **)
+    
+    let min_case_strong n m compat hl hr =
+      let c = coq_CompSpec2Type n m (compare n m) in
+      (match c with
+       | CompEqT -> compat n (min n m) __ (hl __)
+       | CompLtT -> compat n (min n m) __ (hl __)
+       | CompGtT -> compat m (min n m) __ (hr __))
+    
+    (** val min_case :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1
+        -> 'a1 **)
+    
+    let min_case n m x x0 x1 =
+      min_case_strong n m x (fun _ -> x0) (fun _ -> x1)
+    
+    (** val min_dec : float -> float -> bool **)
+    
+    let min_dec n m =
+      min_case n m (fun x y _ h0 -> if h0 then true else false) true false
+   end
+  
+  (** val max_case_strong :
+      float -> float -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
+  
+  let max_case_strong n m x x0 =
+    Private_Dec.max_case_strong n m (fun x1 y _ x2 -> x2) x x0
+  
+  (** val max_case : float -> float -> 'a1 -> 'a1 -> 'a1 **)
+  
+  let max_case n m x x0 =
+    max_case_strong n m (fun _ -> x) (fun _ -> x0)
+  
+  (** val max_dec : float -> float -> bool **)
+  
+  let max_dec =
+    Private_Dec.max_dec
+  
+  (** val min_case_strong :
+      float -> float -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
+  
+  let min_case_strong n m x x0 =
+    Private_Dec.min_case_strong n m (fun x1 y _ x2 -> x2) x x0
+  
+  (** val min_case : float -> float -> 'a1 -> 'a1 -> 'a1 **)
+  
+  let min_case n m x x0 =
+    min_case_strong n m (fun _ -> x) (fun _ -> x0)
+  
+  (** val min_dec : float -> float -> bool **)
+  
+  let min_dec =
+    Private_Dec.min_dec
+ end
+
diff --git a/generator/tests/jsref/BinNat.ml b/generator/tests/jsref/BinNat.ml
new file mode 100644
index 0000000..596cb84
--- /dev/null
+++ b/generator/tests/jsref/BinNat.ml
@@ -0,0 +1,738 @@
+open BinPos
+open Bool0
+open Datatypes
+open Peano
+
+type __ = Obj.t
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
+module N = 
+ struct 
+  type t = float
+  
+  (** val zero : float **)
+  
+  let zero =
+    0.
+  
+  (** val one : float **)
+  
+  let one =
+    1.
+  
+  (** val two : float **)
+  
+  let two =
+    ((fun p -> 2. *. p) 1.)
+  
+  (** val succ_double : float -> float **)
+  
+  let succ_double x =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      1.)
+      (fun p -> ((fun p -> 1. +. (2. *. p))
+      p))
+      x
+  
+  (** val double : float -> float **)
+  
+  let double n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p -> ((fun p -> 2. *. p)
+      p))
+      n
+  
+  (** val succ : float -> float **)
+  
+  let succ = (+.) 1.
+  
+  (** val pred : float -> float **)
+  
+  let pred = (fun x -> x -. 1.)
+  
+  (** val succ_pos : float -> float **)
+  
+  let succ_pos n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      1.)
+      (fun p ->
+      Pos.succ p)
+      n
+  
+  (** val add : float -> float -> float **)
+  
+  let add = (+.)
+  
+  (** val sub : float -> float -> float **)
+  
+  let sub = (-.)
+  
+  (** val mul : float -> float -> float **)
+  
+  let mul = ( *. )
+  
+  (** val compare : float -> float -> comparison **)
+  
+  let compare = fun x y -> if x=y then Eq else if x<y then Lt else Gt
+  
+  (** val eqb : float -> float -> bool **)
+  
+  let rec eqb n m =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        true)
+        (fun p ->
+        false)
+        m)
+      (fun p ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        false)
+        (fun q ->
+        Pos.eqb p q)
+        m)
+      n
+  
+  (** val leb : float -> float -> bool **)
+  
+  let leb x y =
+    match compare x y with
+    | Eq -> true
+    | Lt -> true
+    | Gt -> false
+  
+  (** val ltb : float -> float -> bool **)
+  
+  let ltb x y =
+    match compare x y with
+    | Eq -> false
+    | Lt -> true
+    | Gt -> false
+  
+  (** val min : float -> float -> float **)
+  
+  let min = min
+  
+  (** val max : float -> float -> float **)
+  
+  let max = max
+  
+  (** val div2 : float -> float **)
+  
+  let div2 n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p ->
+        p)
+        (fun p ->
+        p)
+        (fun _ ->
+        0.)
+        p0)
+      n
+  
+  (** val even : float -> bool **)
+  
+  let even n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      true)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        false)
+        (fun p0 ->
+        true)
+        (fun _ ->
+        false)
+        p)
+      n
+  
+  (** val odd : float -> bool **)
+  
+  let odd n =
+    negb (even n)
+  
+  (** val pow : float -> float -> float **)
+  
+  let pow n p =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      1.)
+      (fun p0 ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        0.)
+        (fun q ->
+        (Pos.pow q p0))
+        n)
+      p
+  
+  (** val square : float -> float **)
+  
+  let square n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p ->
+      (Pos.square p))
+      n
+  
+  (** val log2 : float -> float **)
+  
+  let log2 n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p ->
+        (Pos.size p))
+        (fun p ->
+        (Pos.size p))
+        (fun _ ->
+        0.)
+        p0)
+      n
+  
+  (** val size : float -> float **)
+  
+  let size n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p ->
+      (Pos.size p))
+      n
+  
+  (** val size_nat : float -> int **)
+  
+  let size_nat n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0)
+      (fun p ->
+      Pos.size_nat p)
+      n
+  
+  (** val pos_div_eucl : float -> float -> float * float **)
+  
+  let rec pos_div_eucl a b =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun a' ->
+      let (q, r) = pos_div_eucl a' b in
+      let r' = succ_double r in
+      if leb b r' then ((succ_double q), (sub r' b)) else ((double q), r'))
+      (fun a' ->
+      let (q, r) = pos_div_eucl a' b in
+      let r' = double r in
+      if leb b r' then ((succ_double q), (sub r' b)) else ((double q), r'))
+      (fun _ ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ -> (0.,
+        1.))
+        (fun p ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun p0 -> (0.,
+          1.))
+          (fun p0 -> (0.,
+          1.))
+          (fun _ -> (1.,
+          0.))
+          p)
+        b)
+      a
+  
+  (** val div_eucl : float -> float -> float * float **)
+  
+  let div_eucl a b =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ -> (0.,
+      0.))
+      (fun na ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ -> (0.,
+        a))
+        (fun p ->
+        pos_div_eucl na b)
+        b)
+      a
+  
+  (** val div : float -> float -> float **)
+  
+  let div = (fun x y -> if x = 0. then 0. else floor (x /. y))
+  
+  (** val modulo : float -> float -> float **)
+  
+  let modulo = mod_float
+  
+  (** val gcd : float -> float -> float **)
+  
+  let gcd a b =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      b)
+      (fun p ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        a)
+        (fun q ->
+        (Pos.gcd p q))
+        b)
+      a
+  
+  (** val ggcd : float -> float -> float * (float * float) **)
+  
+  let ggcd a b =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ -> (b, (0.,
+      1.)))
+      (fun p ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ -> (a, (1.,
+        0.)))
+        (fun q ->
+        let (g, p0) = Pos.ggcd p q in let (aa, bb) = p0 in (g, (aa, bb)))
+        b)
+      a
+  
+  (** val sqrtrem : float -> float * float **)
+  
+  let sqrtrem n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ -> (0.,
+      0.))
+      (fun p ->
+      let (s, m) = Pos.sqrtrem p in
+      (match m with
+       | Pos.IsNul -> (s, 0.)
+       | Pos.IsPos r -> (s, r)
+       | Pos.IsNeg -> (s, 0.)))
+      n
+  
+  (** val sqrt : float -> float **)
+  
+  let sqrt n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p ->
+      (Pos.sqrt p))
+      n
+  
+  (** val coq_lor : float -> float -> float **)
+  
+  let coq_lor n m =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      m)
+      (fun p ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        n)
+        (fun q ->
+        (Pos.coq_lor p q))
+        m)
+      n
+  
+  (** val coq_land : float -> float -> float **)
+  
+  let coq_land n m =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        0.)
+        (fun q ->
+        Pos.coq_land p q)
+        m)
+      n
+  
+  (** val ldiff : float -> float -> float **)
+  
+  let rec ldiff n m =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        n)
+        (fun q ->
+        Pos.ldiff p q)
+        m)
+      n
+  
+  (** val coq_lxor : float -> float -> float **)
+  
+  let coq_lxor n m =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      m)
+      (fun p ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        n)
+        (fun q ->
+        Pos.coq_lxor p q)
+        m)
+      n
+  
+  (** val shiftl_nat : float -> int -> float **)
+  
+  let shiftl_nat a n =
+    nat_iter n double a
+  
+  (** val shiftr_nat : float -> int -> float **)
+  
+  let shiftr_nat a n =
+    nat_iter n div2 a
+  
+  (** val shiftl : float -> float -> float **)
+  
+  let shiftl a n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun a0 ->
+      (Pos.shiftl a0 n))
+      a
+  
+  (** val shiftr : float -> float -> float **)
+  
+  let shiftr a n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      a)
+      (fun p ->
+      Pos.iter p div2 a)
+      n
+  
+  (** val testbit_nat : float -> int -> bool **)
+  
+  let testbit_nat a =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ x ->
+      false)
+      (fun p ->
+      Pos.testbit_nat p)
+      a
+  
+  (** val testbit : float -> float -> bool **)
+  
+  let testbit a n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      false)
+      (fun p ->
+      Pos.testbit p n)
+      a
+  
+  (** val to_nat : float -> int **)
+  
+  let to_nat a =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0)
+      (fun p ->
+      Pos.to_nat p)
+      a
+  
+  (** val of_nat : int -> float **)
+  
+  let of_nat n =
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      0.)
+      (fun n' ->
+      (Pos.of_succ_nat n'))
+      n
+  
+  (** val iter : float -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
+  
+  let iter n f x =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      x)
+      (fun p ->
+      Pos.iter p f x)
+      n
+  
+  (** val eq_dec : float -> float -> bool **)
+  
+  let eq_dec n m =
+    ((fun f0 fp n -> if n=0. then f0 () else fp n)
+       (fun _ m0 ->
+       (fun f0 fp n -> if n=0. then f0 () else fp n)
+         (fun _ ->
+         true)
+         (fun p ->
+         false)
+         m0)
+       (fun x m0 ->
+       (fun f0 fp n -> if n=0. then f0 () else fp n)
+         (fun _ ->
+         false)
+         (fun p0 ->
+         if Pos.eq_dec x p0 then true else false)
+         m0)
+       n) m
+  
+  (** val discr : float -> float option **)
+  
+  let discr n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      None)
+      (fun p -> Some
+      p)
+      n
+  
+  (** val binary_rect :
+      'a1 -> (float -> 'a1 -> 'a1) -> (float -> 'a1 -> 'a1) -> float -> 'a1 **)
+  
+  let binary_rect f0 f2 fS2 n =
+    let f2' = fun p -> f2 p in
+    let fS2' = fun p -> fS2 p in
+    ((fun f0 fp n -> if n=0. then f0 () else fp n)
+       (fun _ ->
+       f0)
+       (fun p ->
+       let rec f p0 =
+         (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+           (fun p1 ->
+           fS2' p1 (f p1))
+           (fun p1 ->
+           f2' p1 (f p1))
+           (fun _ ->
+           fS2 0. f0)
+           p0
+       in f p)
+       n)
+  
+  (** val binary_rec :
+      'a1 -> (float -> 'a1 -> 'a1) -> (float -> 'a1 -> 'a1) -> float -> 'a1 **)
+  
+  let binary_rec =
+    binary_rect
+  
+  (** val peano_rect : 'a1 -> (float -> 'a1 -> 'a1) -> float -> 'a1 **)
+  
+  let peano_rect f0 f n =
+    let f' = fun p -> f p in
+    ((fun f0 fp n -> if n=0. then f0 () else fp n)
+       (fun _ ->
+       f0)
+       (fun p ->
+       Pos.peano_rect (f 0. f0) f' p)
+       n)
+  
+  (** val peano_rec : 'a1 -> (float -> 'a1 -> 'a1) -> float -> 'a1 **)
+  
+  let peano_rec =
+    peano_rect
+  
+  (** val leb_spec0 : float -> float -> reflect **)
+  
+  let leb_spec0 x y =
+    iff_reflect (leb x y)
+  
+  (** val ltb_spec0 : float -> float -> reflect **)
+  
+  let ltb_spec0 x y =
+    iff_reflect (ltb x y)
+  
+  module Private_BootStrap = 
+   struct 
+    
+   end
+  
+  (** val recursion : 'a1 -> (float -> 'a1 -> 'a1) -> float -> 'a1 **)
+  
+  let recursion x =
+    peano_rect x
+  
+  module Private_OrderTac = 
+   struct 
+    module IsTotal = 
+     struct 
+      
+     end
+    
+    module Tac = 
+     struct 
+      
+     end
+   end
+  
+  module Private_NZPow = 
+   struct 
+    
+   end
+  
+  module Private_NZSqrt = 
+   struct 
+    
+   end
+  
+  (** val sqrt_up : float -> float **)
+  
+  let sqrt_up a =
+    match compare 0. a with
+    | Eq -> 0.
+    | Lt -> succ (sqrt (pred a))
+    | Gt -> 0.
+  
+  (** val log2_up : float -> float **)
+  
+  let log2_up a =
+    match compare 1. a with
+    | Eq -> 0.
+    | Lt -> succ (log2 (pred a))
+    | Gt -> 0.
+  
+  module Private_NZDiv = 
+   struct 
+    
+   end
+  
+  (** val lcm : float -> float -> float **)
+  
+  let lcm a b =
+    mul a (div b (gcd a b))
+  
+  (** val eqb_spec : float -> float -> reflect **)
+  
+  let eqb_spec x y =
+    iff_reflect (eqb x y)
+  
+  (** val b2n : bool -> float **)
+  
+  let b2n = function
+  | true -> 1.
+  | false -> 0.
+  
+  (** val setbit : float -> float -> float **)
+  
+  let setbit a n =
+    coq_lor a (shiftl 1. n)
+  
+  (** val clearbit : float -> float -> float **)
+  
+  let clearbit a n =
+    ldiff a (shiftl 1. n)
+  
+  (** val ones : float -> float **)
+  
+  let ones n =
+    pred (shiftl 1. n)
+  
+  (** val lnot : float -> float -> float **)
+  
+  let lnot a n =
+    coq_lxor a (ones n)
+  
+  module Private_Tac = 
+   struct 
+    
+   end
+  
+  module Private_Dec = 
+   struct 
+    (** val max_case_strong :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> (__ -> 'a1)
+        -> (__ -> 'a1) -> 'a1 **)
+    
+    let max_case_strong n m compat hl hr =
+      let c = coq_CompSpec2Type n m (compare n m) in
+      (match c with
+       | CompEqT -> compat m (max n m) __ (hr __)
+       | CompLtT -> compat m (max n m) __ (hr __)
+       | CompGtT -> compat n (max n m) __ (hl __))
+    
+    (** val max_case :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1
+        -> 'a1 **)
+    
+    let max_case n m x x0 x1 =
+      max_case_strong n m x (fun _ -> x0) (fun _ -> x1)
+    
+    (** val max_dec : float -> float -> bool **)
+    
+    let max_dec n m =
+      max_case n m (fun x y _ h0 -> if h0 then true else false) true false
+    
+    (** val min_case_strong :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> (__ -> 'a1)
+        -> (__ -> 'a1) -> 'a1 **)
+    
+    let min_case_strong n m compat hl hr =
+      let c = coq_CompSpec2Type n m (compare n m) in
+      (match c with
+       | CompEqT -> compat n (min n m) __ (hl __)
+       | CompLtT -> compat n (min n m) __ (hl __)
+       | CompGtT -> compat m (min n m) __ (hr __))
+    
+    (** val min_case :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1
+        -> 'a1 **)
+    
+    let min_case n m x x0 x1 =
+      min_case_strong n m x (fun _ -> x0) (fun _ -> x1)
+    
+    (** val min_dec : float -> float -> bool **)
+    
+    let min_dec n m =
+      min_case n m (fun x y _ h0 -> if h0 then true else false) true false
+   end
+  
+  (** val max_case_strong :
+      float -> float -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
+  
+  let max_case_strong n m x x0 =
+    Private_Dec.max_case_strong n m (fun x1 y _ x2 -> x2) x x0
+  
+  (** val max_case : float -> float -> 'a1 -> 'a1 -> 'a1 **)
+  
+  let max_case n m x x0 =
+    max_case_strong n m (fun _ -> x) (fun _ -> x0)
+  
+  (** val max_dec : float -> float -> bool **)
+  
+  let max_dec =
+    Private_Dec.max_dec
+  
+  (** val min_case_strong :
+      float -> float -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
+  
+  let min_case_strong n m x x0 =
+    Private_Dec.min_case_strong n m (fun x1 y _ x2 -> x2) x x0
+  
+  (** val min_case : float -> float -> 'a1 -> 'a1 -> 'a1 **)
+  
+  let min_case n m x x0 =
+    min_case_strong n m (fun _ -> x) (fun _ -> x0)
+  
+  (** val min_dec : float -> float -> bool **)
+  
+  let min_dec =
+    Private_Dec.min_dec
+ end
+
diff --git a/generator/tests/jsref/BinNums.ml b/generator/tests/jsref/BinNums.ml
new file mode 100644
index 0000000..e69de29
diff --git a/generator/tests/jsref/BinPos.ml b/generator/tests/jsref/BinPos.ml
new file mode 100644
index 0000000..1edc645
--- /dev/null
+++ b/generator/tests/jsref/BinPos.ml
@@ -0,0 +1,1060 @@
+open BinPosDef
+open Bool0
+open Datatypes
+open Peano
+
+type __ = Obj.t
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
+module Pos = 
+ struct 
+  type t = float
+  
+  (** val succ : float -> float **)
+  
+  let rec succ = (+.) 1.
+  
+  (** val add : float -> float -> float **)
+  
+  let rec add = (+.)
+  
+  (** val add_carry : float -> float -> float **)
+  
+  and add_carry x y =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q -> (fun p -> 1. +. (2. *. p))
+        (add_carry p q))
+        (fun q -> (fun p -> 2. *. p)
+        (add_carry p q))
+        (fun _ -> (fun p -> 1. +. (2. *. p))
+        (succ p))
+        y)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q -> (fun p -> 2. *. p)
+        (add_carry p q))
+        (fun q -> (fun p -> 1. +. (2. *. p))
+        (add p q))
+        (fun _ -> (fun p -> 2. *. p)
+        (succ p))
+        y)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q -> (fun p -> 1. +. (2. *. p))
+        (succ q))
+        (fun q -> (fun p -> 2. *. p)
+        (succ q))
+        (fun _ -> (fun p -> 1. +. (2. *. p))
+        1.)
+        y)
+      x
+  
+  (** val pred_double : float -> float **)
+  
+  let rec pred_double x =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p -> (fun p -> 1. +. (2. *. p)) ((fun p -> 2. *. p)
+      p))
+      (fun p -> (fun p -> 1. +. (2. *. p))
+      (pred_double p))
+      (fun _ ->
+      1.)
+      x
+  
+  (** val pred : float -> float **)
+  
+  let pred = (fun x -> x -. 1.)
+  
+  (** val pred_N : float -> float **)
+  
+  let pred_N x =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p -> ((fun p -> 2. *. p)
+      p))
+      (fun p ->
+      (pred_double p))
+      (fun _ ->
+      0.)
+      x
+  
+  type mask = Pos.mask =
+  | IsNul [@f]  (** Auto Generated Attributes **)
+  | IsPos  [@f label0] of float (** Auto Generated Attributes **)
+  | IsNeg [@f]  (** Auto Generated Attributes **)
+  
+  (** val mask_rect : 'a1 -> (float -> 'a1) -> 'a1 -> mask -> 'a1 **)
+  
+  let mask_rect f f0 f1 = function
+  | IsNul -> f
+  | IsPos x -> f0 x
+  | IsNeg -> f1
+  
+  (** val mask_rec : 'a1 -> (float -> 'a1) -> 'a1 -> mask -> 'a1 **)
+  
+  let mask_rec f f0 f1 = function
+  | IsNul -> f
+  | IsPos x -> f0 x
+  | IsNeg -> f1
+  
+  (** val succ_double_mask : mask -> mask **)
+  
+  let succ_double_mask = function
+  | IsNul -> IsPos 1.
+  | IsPos p -> IsPos ((fun p -> 1. +. (2. *. p)) p)
+  | IsNeg -> IsNeg
+  
+  (** val double_mask : mask -> mask **)
+  
+  let double_mask = function
+  | IsNul -> IsNul
+  | IsPos p -> IsPos ((fun p -> 2. *. p) p)
+  | IsNeg -> IsNeg
+  
+  (** val double_pred_mask : float -> mask **)
+  
+  let double_pred_mask x =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p -> IsPos ((fun p -> 2. *. p) ((fun p -> 2. *. p)
+      p)))
+      (fun p -> IsPos ((fun p -> 2. *. p)
+      (pred_double p)))
+      (fun _ ->
+      IsNul)
+      x
+  
+  (** val pred_mask : mask -> mask **)
+  
+  let pred_mask = function
+  | IsNul -> IsNeg
+  | IsPos q ->
+    ((fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+       (fun p0 -> IsPos
+       (pred q))
+       (fun p0 -> IsPos
+       (pred q))
+       (fun _ ->
+       IsNul)
+       q)
+  | IsNeg -> IsNeg
+  
+  (** val sub_mask : float -> float -> mask **)
+  
+  let rec sub_mask x y =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        double_mask (sub_mask p q))
+        (fun q ->
+        succ_double_mask (sub_mask p q))
+        (fun _ -> IsPos ((fun p -> 2. *. p)
+        p))
+        y)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        succ_double_mask (sub_mask_carry p q))
+        (fun q ->
+        double_mask (sub_mask p q))
+        (fun _ -> IsPos
+        (pred_double p))
+        y)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p ->
+        IsNeg)
+        (fun p ->
+        IsNeg)
+        (fun _ ->
+        IsNul)
+        y)
+      x
+  
+  (** val sub_mask_carry : float -> float -> mask **)
+  
+  and sub_mask_carry x y =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        succ_double_mask (sub_mask_carry p q))
+        (fun q ->
+        double_mask (sub_mask p q))
+        (fun _ -> IsPos
+        (pred_double p))
+        y)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        double_mask (sub_mask_carry p q))
+        (fun q ->
+        succ_double_mask (sub_mask_carry p q))
+        (fun _ ->
+        double_pred_mask p)
+        y)
+      (fun _ ->
+      IsNeg)
+      x
+  
+  (** val sub : float -> float -> float **)
+  
+  let sub = (-.)
+  
+  (** val mul : float -> float -> float **)
+  
+  let rec mul = ( *. )
+  
+  (** val iter : float -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
+  
+  let rec iter n f x =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun n' ->
+      f (iter n' f (iter n' f x)))
+      (fun n' ->
+      iter n' f (iter n' f x))
+      (fun _ ->
+      f x)
+      n
+  
+  (** val pow : float -> float -> float **)
+  
+  let pow x y =
+    iter y (mul x) 1.
+  
+  (** val square : float -> float **)
+  
+  let rec square p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 -> (fun p -> 1. +. (2. *. p)) ((fun p -> 2. *. p)
+      (add (square p0) p0)))
+      (fun p0 -> (fun p -> 2. *. p) ((fun p -> 2. *. p)
+      (square p0)))
+      (fun _ ->
+      1.)
+      p
+  
+  (** val div2 : float -> float **)
+  
+  let div2 p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      p0)
+      (fun p0 ->
+      p0)
+      (fun _ ->
+      1.)
+      p
+  
+  (** val div2_up : float -> float **)
+  
+  let div2_up p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      succ p0)
+      (fun p0 ->
+      p0)
+      (fun _ ->
+      1.)
+      p
+  
+  (** val size_nat : float -> int **)
+  
+  let rec size_nat p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 -> Pervasives.succ
+      (size_nat p0))
+      (fun p0 -> Pervasives.succ
+      (size_nat p0))
+      (fun _ -> Pervasives.succ
+      0)
+      p
+  
+  (** val size : float -> float **)
+  
+  let rec size p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      succ (size p0))
+      (fun p0 ->
+      succ (size p0))
+      (fun _ ->
+      1.)
+      p
+  
+  (** val compare_cont : float -> float -> comparison -> comparison **)
+  
+  let rec compare_cont = fun x y c -> if x=y then c else if x<y then Lt else Gt
+  
+  (** val compare : float -> float -> comparison **)
+  
+  let compare = fun x y -> if x=y then Eq else if x<y then Lt else Gt
+  
+  (** val min : float -> float -> float **)
+  
+  let min = min
+  
+  (** val max : float -> float -> float **)
+  
+  let max = max
+  
+  (** val eqb : float -> float -> bool **)
+  
+  let rec eqb p q =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        eqb p0 q0)
+        (fun p1 ->
+        false)
+        (fun _ ->
+        false)
+        q)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p1 ->
+        false)
+        (fun q0 ->
+        eqb p0 q0)
+        (fun _ ->
+        false)
+        q)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        false)
+        (fun p0 ->
+        false)
+        (fun _ ->
+        true)
+        q)
+      p
+  
+  (** val leb : float -> float -> bool **)
+  
+  let leb x y =
+    match compare x y with
+    | Eq -> true
+    | Lt -> true
+    | Gt -> false
+  
+  (** val ltb : float -> float -> bool **)
+  
+  let ltb x y =
+    match compare x y with
+    | Eq -> false
+    | Lt -> true
+    | Gt -> false
+  
+  (** val sqrtrem_step :
+      (float -> float) -> (float -> float) -> (float * mask) -> float * mask **)
+  
+  let sqrtrem_step f g = function
+  | (s, y) ->
+    (match y with
+     | IsNul ->
+       (((fun p -> 2. *. p) s),
+         (sub_mask (g (f 1.)) ((fun p -> 2. *. p) ((fun p -> 2. *. p) 1.))))
+     | IsPos r ->
+       let s' = (fun p -> 1. +. (2. *. p)) ((fun p -> 2. *. p) s) in
+       let r' = g (f r) in
+       if leb s' r'
+       then (((fun p -> 1. +. (2. *. p)) s), (sub_mask r' s'))
+       else (((fun p -> 2. *. p) s), (IsPos r'))
+     | IsNeg ->
+       (((fun p -> 2. *. p) s),
+         (sub_mask (g (f 1.)) ((fun p -> 2. *. p) ((fun p -> 2. *. p) 1.)))))
+  
+  (** val sqrtrem : float -> float * mask **)
+  
+  let rec sqrtrem p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p1 ->
+        sqrtrem_step (fun x -> (fun p -> 1. +. (2. *. p)) x) (fun x ->
+          (fun p -> 1. +. (2. *. p)) x) (sqrtrem p1))
+        (fun p1 ->
+        sqrtrem_step (fun x -> (fun p -> 2. *. p) x) (fun x ->
+          (fun p -> 1. +. (2. *. p)) x) (sqrtrem p1))
+        (fun _ -> (1., (IsPos ((fun p -> 2. *. p)
+        1.))))
+        p0)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p1 ->
+        sqrtrem_step (fun x -> (fun p -> 1. +. (2. *. p)) x) (fun x ->
+          (fun p -> 2. *. p) x) (sqrtrem p1))
+        (fun p1 ->
+        sqrtrem_step (fun x -> (fun p -> 2. *. p) x) (fun x ->
+          (fun p -> 2. *. p) x) (sqrtrem p1))
+        (fun _ -> (1., (IsPos
+        1.)))
+        p0)
+      (fun _ -> (1.,
+      IsNul))
+      p
+  
+  (** val sqrt : float -> float **)
+  
+  let sqrt p =
+    fst (sqrtrem p)
+  
+  (** val gcdn : int -> float -> float -> float **)
+  
+  let rec gcdn n a b =
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      1.)
+      (fun n0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun a' ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun b' ->
+          match compare a' b' with
+          | Eq -> a
+          | Lt -> gcdn n0 (sub b' a') a
+          | Gt -> gcdn n0 (sub a' b') b)
+          (fun b0 ->
+          gcdn n0 a b0)
+          (fun _ ->
+          1.)
+          b)
+        (fun a0 ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun p ->
+          gcdn n0 a0 b)
+          (fun b0 -> (fun p -> 2. *. p)
+          (gcdn n0 a0 b0))
+          (fun _ ->
+          1.)
+          b)
+        (fun _ ->
+        1.)
+        a)
+      n
+  
+  (** val gcd : float -> float -> float **)
+  
+  let gcd a b =
+    gcdn (plus (size_nat a) (size_nat b)) a b
+  
+  (** val ggcdn : int -> float -> float -> float * (float * float) **)
+  
+  let rec ggcdn n a b =
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ -> (1., (a,
+      b)))
+      (fun n0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun a' ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun b' ->
+          match compare a' b' with
+          | Eq -> (a, (1., 1.))
+          | Lt ->
+            let (g, p) = ggcdn n0 (sub b' a') a in
+            let (ba, aa) = p in (g, (aa, (add aa ((fun p -> 2. *. p) ba))))
+          | Gt ->
+            let (g, p) = ggcdn n0 (sub a' b') b in
+            let (ab, bb) = p in (g, ((add bb ((fun p -> 2. *. p) ab)), bb)))
+          (fun b0 ->
+          let (g, p) = ggcdn n0 a b0 in
+          let (aa, bb) = p in (g, (aa, ((fun p -> 2. *. p) bb))))
+          (fun _ -> (1., (a,
+          1.)))
+          b)
+        (fun a0 ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun p ->
+          let (g, p0) = ggcdn n0 a0 b in
+          let (aa, bb) = p0 in (g, (((fun p -> 2. *. p) aa), bb)))
+          (fun b0 ->
+          let (g, p) = ggcdn n0 a0 b0 in (((fun p -> 2. *. p) g), p))
+          (fun _ -> (1., (a,
+          1.)))
+          b)
+        (fun _ -> (1., (1.,
+        b)))
+        a)
+      n
+  
+  (** val ggcd : float -> float -> float * (float * float) **)
+  
+  let ggcd a b =
+    ggcdn (plus (size_nat a) (size_nat b)) a b
+  
+  (** val coq_Nsucc_double : float -> float **)
+  
+  let coq_Nsucc_double x =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      1.)
+      (fun p -> ((fun p -> 1. +. (2. *. p))
+      p))
+      x
+  
+  (** val coq_Ndouble : float -> float **)
+  
+  let coq_Ndouble n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p -> ((fun p -> 2. *. p)
+      p))
+      n
+  
+  (** val coq_lor : float -> float -> float **)
+  
+  let rec coq_lor p q =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 -> (fun p -> 1. +. (2. *. p))
+        (coq_lor p0 q0))
+        (fun q0 -> (fun p -> 1. +. (2. *. p))
+        (coq_lor p0 q0))
+        (fun _ ->
+        p)
+        q)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 -> (fun p -> 1. +. (2. *. p))
+        (coq_lor p0 q0))
+        (fun q0 -> (fun p -> 2. *. p)
+        (coq_lor p0 q0))
+        (fun _ -> (fun p -> 1. +. (2. *. p))
+        p0)
+        q)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        q)
+        (fun q0 -> (fun p -> 1. +. (2. *. p))
+        q0)
+        (fun _ ->
+        q)
+        q)
+      p
+  
+  (** val coq_land : float -> float -> float **)
+  
+  let rec coq_land p q =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Nsucc_double (coq_land p0 q0))
+        (fun q0 ->
+        coq_Ndouble (coq_land p0 q0))
+        (fun _ ->
+        1.)
+        q)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Ndouble (coq_land p0 q0))
+        (fun q0 ->
+        coq_Ndouble (coq_land p0 q0))
+        (fun _ ->
+        0.)
+        q)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        1.)
+        (fun q0 ->
+        0.)
+        (fun _ ->
+        1.)
+        q)
+      p
+  
+  (** val ldiff : float -> float -> float **)
+  
+  let rec ldiff p q =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Ndouble (ldiff p0 q0))
+        (fun q0 ->
+        coq_Nsucc_double (ldiff p0 q0))
+        (fun _ -> ((fun p -> 2. *. p)
+        p0))
+        q)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Ndouble (ldiff p0 q0))
+        (fun q0 ->
+        coq_Ndouble (ldiff p0 q0))
+        (fun _ ->
+        p)
+        q)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        0.)
+        (fun q0 ->
+        1.)
+        (fun _ ->
+        0.)
+        q)
+      p
+  
+  (** val coq_lxor : float -> float -> float **)
+  
+  let rec coq_lxor p q =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Ndouble (coq_lxor p0 q0))
+        (fun q0 ->
+        coq_Nsucc_double (coq_lxor p0 q0))
+        (fun _ -> ((fun p -> 2. *. p)
+        p0))
+        q)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Nsucc_double (coq_lxor p0 q0))
+        (fun q0 ->
+        coq_Ndouble (coq_lxor p0 q0))
+        (fun _ -> ((fun p -> 1. +. (2. *. p))
+        p0))
+        q)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 -> ((fun p -> 2. *. p)
+        q0))
+        (fun q0 -> ((fun p -> 1. +. (2. *. p))
+        q0))
+        (fun _ ->
+        0.)
+        q)
+      p
+  
+  (** val shiftl_nat : float -> int -> float **)
+  
+  let shiftl_nat p n =
+    nat_iter n (fun x -> (fun p -> 2. *. p) x) p
+  
+  (** val shiftr_nat : float -> int -> float **)
+  
+  let shiftr_nat p n =
+    nat_iter n div2 p
+  
+  (** val shiftl : float -> float -> float **)
+  
+  let shiftl p n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      p)
+      (fun n0 ->
+      iter n0 (fun x -> (fun p -> 2. *. p) x) p)
+      n
+  
+  (** val shiftr : float -> float -> float **)
+  
+  let shiftr p n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      p)
+      (fun n0 ->
+      iter n0 div2 p)
+      n
+  
+  (** val testbit_nat : float -> int -> bool **)
+  
+  let rec testbit_nat p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 n ->
+      (fun fO fS n -> if n=0 then fO () else fS (n-1))
+        (fun _ ->
+        true)
+        (fun n' ->
+        testbit_nat p0 n')
+        n)
+      (fun p0 n ->
+      (fun fO fS n -> if n=0 then fO () else fS (n-1))
+        (fun _ ->
+        false)
+        (fun n' ->
+        testbit_nat p0 n')
+        n)
+      (fun _ n ->
+      (fun fO fS n -> if n=0 then fO () else fS (n-1))
+        (fun _ ->
+        true)
+        (fun n0 ->
+        false)
+        n)
+      p
+  
+  (** val testbit : float -> float -> bool **)
+  
+  let rec testbit p n =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        true)
+        (fun n0 ->
+        testbit p0 (pred_N n0))
+        n)
+      (fun p0 ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        false)
+        (fun n0 ->
+        testbit p0 (pred_N n0))
+        n)
+      (fun _ ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        true)
+        (fun p0 ->
+        false)
+        n)
+      p
+  
+  (** val iter_op : ('a1 -> 'a1 -> 'a1) -> float -> 'a1 -> 'a1 **)
+  
+  let iter_op op =
+    let rec iter0 p a =
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        op a (iter0 p0 (op a a)))
+        (fun p0 ->
+        iter0 p0 (op a a))
+        (fun _ ->
+        a)
+        p
+    in iter0
+  
+  (** val to_nat : float -> int **)
+  
+  let to_nat x =
+    iter_op plus x (Pervasives.succ 0)
+  
+  (** val of_nat : int -> float **)
+  
+  let rec of_nat n =
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      1.)
+      (fun x ->
+      (fun fO fS n -> if n=0 then fO () else fS (n-1))
+        (fun _ ->
+        1.)
+        (fun n0 ->
+        succ (of_nat x))
+        x)
+      n
+  
+  (** val of_succ_nat : int -> float **)
+  
+  let rec of_succ_nat n =
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      1.)
+      (fun x ->
+      succ (of_succ_nat x))
+      n
+  
+  (** val eq_dec : float -> float -> bool **)
+  
+  let eq_dec x y =
+    let rec f p =
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 y0 ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun p1 ->
+          if f p0 p1 then true else false)
+          (fun p1 ->
+          false)
+          (fun _ ->
+          false)
+          y0)
+        (fun p0 y0 ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun p1 ->
+          false)
+          (fun p1 ->
+          if f p0 p1 then true else false)
+          (fun _ ->
+          false)
+          y0)
+        (fun _ y0 ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun p0 ->
+          false)
+          (fun p0 ->
+          false)
+          (fun _ ->
+          true)
+          y0)
+        p
+    in f x y
+  
+  (** val peano_rect : 'a1 -> (float -> 'a1 -> 'a1) -> float -> 'a1 **)
+  
+  let rec peano_rect a f p =
+    let f2 =
+      peano_rect (f 1. a) (fun p0 x ->
+        f (succ ((fun p -> 2. *. p) p0)) (f ((fun p -> 2. *. p) p0) x))
+    in
+    ((fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+       (fun q ->
+       f ((fun p -> 2. *. p) q) (f2 q))
+       (fun q ->
+       f2 q)
+       (fun _ ->
+       a)
+       p)
+  
+  (** val peano_rec : 'a1 -> (float -> 'a1 -> 'a1) -> float -> 'a1 **)
+  
+  let peano_rec =
+    peano_rect
+  
+  type coq_PeanoView =
+  | PeanoOne [@f]  (** Auto Generated Attributes **)
+  | PeanoSucc  [@f label0, label1] of float * coq_PeanoView (** Auto Generated Attributes **)
+  
+  (** val coq_PeanoView_rect :
+      'a1 -> (float -> coq_PeanoView -> 'a1 -> 'a1) -> float -> coq_PeanoView
+      -> 'a1 **)
+  
+  let coq_PeanoView_rect f f0 =
+    let rec f1 p = function
+    | PeanoOne -> f
+    | PeanoSucc (p1, p2) -> f0 p1 p2 (f1 p1 p2)
+    in f1
+  
+  (** val coq_PeanoView_rec :
+      'a1 -> (float -> coq_PeanoView -> 'a1 -> 'a1) -> float -> coq_PeanoView
+      -> 'a1 **)
+  
+  let coq_PeanoView_rec f f0 =
+    let rec f1 p = function
+    | PeanoOne -> f
+    | PeanoSucc (p1, p2) -> f0 p1 p2 (f1 p1 p2)
+    in f1
+  
+  (** val peanoView_xO : float -> coq_PeanoView -> coq_PeanoView **)
+  
+  let rec peanoView_xO p = function
+  | PeanoOne -> PeanoSucc (1., PeanoOne)
+  | PeanoSucc (p0, q0) ->
+    PeanoSucc ((succ ((fun p -> 2. *. p) p0)), (PeanoSucc
+      (((fun p -> 2. *. p) p0), (peanoView_xO p0 q0))))
+  
+  (** val peanoView_xI : float -> coq_PeanoView -> coq_PeanoView **)
+  
+  let rec peanoView_xI p = function
+  | PeanoOne -> PeanoSucc ((succ 1.), (PeanoSucc (1., PeanoOne)))
+  | PeanoSucc (p0, q0) ->
+    PeanoSucc ((succ ((fun p -> 1. +. (2. *. p)) p0)), (PeanoSucc
+      (((fun p -> 1. +. (2. *. p)) p0), (peanoView_xI p0 q0))))
+  
+  (** val peanoView : float -> coq_PeanoView **)
+  
+  let rec peanoView p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      peanoView_xI p0 (peanoView p0))
+      (fun p0 ->
+      peanoView_xO p0 (peanoView p0))
+      (fun _ ->
+      PeanoOne)
+      p
+  
+  (** val coq_PeanoView_iter :
+      'a1 -> (float -> 'a1 -> 'a1) -> float -> coq_PeanoView -> 'a1 **)
+  
+  let coq_PeanoView_iter a f =
+    let rec iter0 p = function
+    | PeanoOne -> a
+    | PeanoSucc (p0, q0) -> f p0 (iter0 p0 q0)
+    in iter0
+  
+  (** val eqb_spec : float -> float -> reflect **)
+  
+  let eqb_spec x y =
+    iff_reflect (eqb x y)
+  
+  (** val switch_Eq : comparison -> comparison -> comparison **)
+  
+  let switch_Eq c = function
+  | Eq -> c
+  | Lt -> Lt
+  | Gt -> Gt
+  
+  (** val mask2cmp : mask -> comparison **)
+  
+  let mask2cmp = function
+  | IsNul -> Eq
+  | IsPos p0 -> Gt
+  | IsNeg -> Lt
+  
+  (** val leb_spec0 : float -> float -> reflect **)
+  
+  let leb_spec0 x y =
+    iff_reflect (leb x y)
+  
+  (** val ltb_spec0 : float -> float -> reflect **)
+  
+  let ltb_spec0 x y =
+    iff_reflect (ltb x y)
+  
+  module Private_Tac = 
+   struct 
+    
+   end
+  
+  module Private_Dec = 
+   struct 
+    (** val max_case_strong :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> (__ -> 'a1)
+        -> (__ -> 'a1) -> 'a1 **)
+    
+    let max_case_strong n m compat hl hr =
+      let c = coq_CompSpec2Type n m (compare n m) in
+      (match c with
+       | CompEqT -> compat m (max n m) __ (hr __)
+       | CompLtT -> compat m (max n m) __ (hr __)
+       | CompGtT -> compat n (max n m) __ (hl __))
+    
+    (** val max_case :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1
+        -> 'a1 **)
+    
+    let max_case n m x x0 x1 =
+      max_case_strong n m x (fun _ -> x0) (fun _ -> x1)
+    
+    (** val max_dec : float -> float -> bool **)
+    
+    let max_dec n m =
+      max_case n m (fun x y _ h0 -> if h0 then true else false) true false
+    
+    (** val min_case_strong :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> (__ -> 'a1)
+        -> (__ -> 'a1) -> 'a1 **)
+    
+    let min_case_strong n m compat hl hr =
+      let c = coq_CompSpec2Type n m (compare n m) in
+      (match c with
+       | CompEqT -> compat n (min n m) __ (hl __)
+       | CompLtT -> compat n (min n m) __ (hl __)
+       | CompGtT -> compat m (min n m) __ (hr __))
+    
+    (** val min_case :
+        float -> float -> (float -> float -> __ -> 'a1 -> 'a1) -> 'a1 -> 'a1
+        -> 'a1 **)
+    
+    let min_case n m x x0 x1 =
+      min_case_strong n m x (fun _ -> x0) (fun _ -> x1)
+    
+    (** val min_dec : float -> float -> bool **)
+    
+    let min_dec n m =
+      min_case n m (fun x y _ h0 -> if h0 then true else false) true false
+   end
+  
+  (** val max_case_strong :
+      float -> float -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
+  
+  let max_case_strong n m x x0 =
+    Private_Dec.max_case_strong n m (fun x1 y _ x2 -> x2) x x0
+  
+  (** val max_case : float -> float -> 'a1 -> 'a1 -> 'a1 **)
+  
+  let max_case n m x x0 =
+    max_case_strong n m (fun _ -> x) (fun _ -> x0)
+  
+  (** val max_dec : float -> float -> bool **)
+  
+  let max_dec =
+    Private_Dec.max_dec
+  
+  (** val min_case_strong :
+      float -> float -> (__ -> 'a1) -> (__ -> 'a1) -> 'a1 **)
+  
+  let min_case_strong n m x x0 =
+    Private_Dec.min_case_strong n m (fun x1 y _ x2 -> x2) x x0
+  
+  (** val min_case : float -> float -> 'a1 -> 'a1 -> 'a1 **)
+  
+  let min_case n m x x0 =
+    min_case_strong n m (fun _ -> x) (fun _ -> x0)
+  
+  (** val min_dec : float -> float -> bool **)
+  
+  let min_dec =
+    Private_Dec.min_dec
+ end
+
diff --git a/generator/tests/jsref/BinPosDef.ml b/generator/tests/jsref/BinPosDef.ml
new file mode 100644
index 0000000..130f42a
--- /dev/null
+++ b/generator/tests/jsref/BinPosDef.ml
@@ -0,0 +1,923 @@
+open Datatypes
+open Peano
+
+module Pos = 
+ struct 
+  type t = float
+  
+  (** val succ : float -> float **)
+  
+  let rec succ x =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p -> (fun p -> 2. *. p)
+      (succ p))
+      (fun p -> (fun p -> 1. +. (2. *. p))
+      p)
+      (fun _ -> (fun p -> 2. *. p)
+      1.)
+      x
+  
+  (** val add : float -> float -> float **)
+  
+  let rec add x y =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q -> (fun p -> 2. *. p)
+        (add_carry p q))
+        (fun q -> (fun p -> 1. +. (2. *. p))
+        (add p q))
+        (fun _ -> (fun p -> 2. *. p)
+        (succ p))
+        y)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q -> (fun p -> 1. +. (2. *. p))
+        (add p q))
+        (fun q -> (fun p -> 2. *. p)
+        (add p q))
+        (fun _ -> (fun p -> 1. +. (2. *. p))
+        p)
+        y)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q -> (fun p -> 2. *. p)
+        (succ q))
+        (fun q -> (fun p -> 1. +. (2. *. p))
+        q)
+        (fun _ -> (fun p -> 2. *. p)
+        1.)
+        y)
+      x
+  
+  (** val add_carry : float -> float -> float **)
+  
+  and add_carry x y =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q -> (fun p -> 1. +. (2. *. p))
+        (add_carry p q))
+        (fun q -> (fun p -> 2. *. p)
+        (add_carry p q))
+        (fun _ -> (fun p -> 1. +. (2. *. p))
+        (succ p))
+        y)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q -> (fun p -> 2. *. p)
+        (add_carry p q))
+        (fun q -> (fun p -> 1. +. (2. *. p))
+        (add p q))
+        (fun _ -> (fun p -> 2. *. p)
+        (succ p))
+        y)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q -> (fun p -> 1. +. (2. *. p))
+        (succ q))
+        (fun q -> (fun p -> 2. *. p)
+        (succ q))
+        (fun _ -> (fun p -> 1. +. (2. *. p))
+        1.)
+        y)
+      x
+  
+  (** val pred_double : float -> float **)
+  
+  let rec pred_double x =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p -> (fun p -> 1. +. (2. *. p)) ((fun p -> 2. *. p)
+      p))
+      (fun p -> (fun p -> 1. +. (2. *. p))
+      (pred_double p))
+      (fun _ ->
+      1.)
+      x
+  
+  (** val pred : float -> float **)
+  
+  let pred x =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p -> (fun p -> 2. *. p)
+      p)
+      (fun p ->
+      pred_double p)
+      (fun _ ->
+      1.)
+      x
+  
+  (** val pred_N : float -> float **)
+  
+  let pred_N x =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p -> ((fun p -> 2. *. p)
+      p))
+      (fun p ->
+      (pred_double p))
+      (fun _ ->
+      0.)
+      x
+  
+  type mask =
+  | IsNul [@f]  (** Auto Generated Attributes **)
+  | IsPos  [@f label0] of float (** Auto Generated Attributes **)
+  | IsNeg [@f]  (** Auto Generated Attributes **)
+  
+  (** val mask_rect : 'a1 -> (float -> 'a1) -> 'a1 -> mask -> 'a1 **)
+  
+  let mask_rect f f0 f1 = function
+  | IsNul -> f
+  | IsPos x -> f0 x
+  | IsNeg -> f1
+  
+  (** val mask_rec : 'a1 -> (float -> 'a1) -> 'a1 -> mask -> 'a1 **)
+  
+  let mask_rec f f0 f1 = function
+  | IsNul -> f
+  | IsPos x -> f0 x
+  | IsNeg -> f1
+  
+  (** val succ_double_mask : mask -> mask **)
+  
+  let succ_double_mask = function
+  | IsNul -> IsPos 1.
+  | IsPos p -> IsPos ((fun p -> 1. +. (2. *. p)) p)
+  | IsNeg -> IsNeg
+  
+  (** val double_mask : mask -> mask **)
+  
+  let double_mask = function
+  | IsNul -> IsNul
+  | IsPos p -> IsPos ((fun p -> 2. *. p) p)
+  | IsNeg -> IsNeg
+  
+  (** val double_pred_mask : float -> mask **)
+  
+  let double_pred_mask x =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p -> IsPos ((fun p -> 2. *. p) ((fun p -> 2. *. p)
+      p)))
+      (fun p -> IsPos ((fun p -> 2. *. p)
+      (pred_double p)))
+      (fun _ ->
+      IsNul)
+      x
+  
+  (** val pred_mask : mask -> mask **)
+  
+  let pred_mask = function
+  | IsNul -> IsNeg
+  | IsPos q ->
+    ((fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+       (fun p0 -> IsPos
+       (pred q))
+       (fun p0 -> IsPos
+       (pred q))
+       (fun _ ->
+       IsNul)
+       q)
+  | IsNeg -> IsNeg
+  
+  (** val sub_mask : float -> float -> mask **)
+  
+  let rec sub_mask x y =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        double_mask (sub_mask p q))
+        (fun q ->
+        succ_double_mask (sub_mask p q))
+        (fun _ -> IsPos ((fun p -> 2. *. p)
+        p))
+        y)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        succ_double_mask (sub_mask_carry p q))
+        (fun q ->
+        double_mask (sub_mask p q))
+        (fun _ -> IsPos
+        (pred_double p))
+        y)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p ->
+        IsNeg)
+        (fun p ->
+        IsNeg)
+        (fun _ ->
+        IsNul)
+        y)
+      x
+  
+  (** val sub_mask_carry : float -> float -> mask **)
+  
+  and sub_mask_carry x y =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        succ_double_mask (sub_mask_carry p q))
+        (fun q ->
+        double_mask (sub_mask p q))
+        (fun _ -> IsPos
+        (pred_double p))
+        y)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        double_mask (sub_mask_carry p q))
+        (fun q ->
+        succ_double_mask (sub_mask_carry p q))
+        (fun _ ->
+        double_pred_mask p)
+        y)
+      (fun _ ->
+      IsNeg)
+      x
+  
+  (** val sub : float -> float -> float **)
+  
+  let sub x y =
+    match sub_mask x y with
+    | IsNul -> 1.
+    | IsPos z -> z
+    | IsNeg -> 1.
+  
+  (** val mul : float -> float -> float **)
+  
+  let rec mul x y =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p ->
+      add y ((fun p -> 2. *. p) (mul p y)))
+      (fun p -> (fun p -> 2. *. p)
+      (mul p y))
+      (fun _ ->
+      y)
+      x
+  
+  (** val iter : float -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
+  
+  let rec iter n f x =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun n' ->
+      f (iter n' f (iter n' f x)))
+      (fun n' ->
+      iter n' f (iter n' f x))
+      (fun _ ->
+      f x)
+      n
+  
+  (** val pow : float -> float -> float **)
+  
+  let pow x y =
+    iter y (mul x) 1.
+  
+  (** val square : float -> float **)
+  
+  let rec square p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 -> (fun p -> 1. +. (2. *. p)) ((fun p -> 2. *. p)
+      (add (square p0) p0)))
+      (fun p0 -> (fun p -> 2. *. p) ((fun p -> 2. *. p)
+      (square p0)))
+      (fun _ ->
+      1.)
+      p
+  
+  (** val div2 : float -> float **)
+  
+  let div2 p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      p0)
+      (fun p0 ->
+      p0)
+      (fun _ ->
+      1.)
+      p
+  
+  (** val div2_up : float -> float **)
+  
+  let div2_up p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      succ p0)
+      (fun p0 ->
+      p0)
+      (fun _ ->
+      1.)
+      p
+  
+  (** val size_nat : float -> int **)
+  
+  let rec size_nat p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 -> Pervasives.succ
+      (size_nat p0))
+      (fun p0 -> Pervasives.succ
+      (size_nat p0))
+      (fun _ -> Pervasives.succ
+      0)
+      p
+  
+  (** val size : float -> float **)
+  
+  let rec size p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      succ (size p0))
+      (fun p0 ->
+      succ (size p0))
+      (fun _ ->
+      1.)
+      p
+  
+  (** val compare_cont : float -> float -> comparison -> comparison **)
+  
+  let rec compare_cont x y r =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        compare_cont p q r)
+        (fun q ->
+        compare_cont p q Gt)
+        (fun _ ->
+        Gt)
+        y)
+      (fun p ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        compare_cont p q Lt)
+        (fun q ->
+        compare_cont p q r)
+        (fun _ ->
+        Gt)
+        y)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q ->
+        Lt)
+        (fun q ->
+        Lt)
+        (fun _ ->
+        r)
+        y)
+      x
+  
+  (** val compare : float -> float -> comparison **)
+  
+  let compare x y =
+    compare_cont x y Eq
+  
+  (** val min : float -> float -> float **)
+  
+  let min p p' =
+    match compare p p' with
+    | Eq -> p
+    | Lt -> p
+    | Gt -> p'
+  
+  (** val max : float -> float -> float **)
+  
+  let max p p' =
+    match compare p p' with
+    | Eq -> p'
+    | Lt -> p'
+    | Gt -> p
+  
+  (** val eqb : float -> float -> bool **)
+  
+  let rec eqb p q =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        eqb p0 q0)
+        (fun p1 ->
+        false)
+        (fun _ ->
+        false)
+        q)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p1 ->
+        false)
+        (fun q0 ->
+        eqb p0 q0)
+        (fun _ ->
+        false)
+        q)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        false)
+        (fun p0 ->
+        false)
+        (fun _ ->
+        true)
+        q)
+      p
+  
+  (** val leb : float -> float -> bool **)
+  
+  let leb x y =
+    match compare x y with
+    | Eq -> true
+    | Lt -> true
+    | Gt -> false
+  
+  (** val ltb : float -> float -> bool **)
+  
+  let ltb x y =
+    match compare x y with
+    | Eq -> false
+    | Lt -> true
+    | Gt -> false
+  
+  (** val sqrtrem_step :
+      (float -> float) -> (float -> float) -> (float * mask) -> float * mask **)
+  
+  let sqrtrem_step f g = function
+  | (s, y) ->
+    (match y with
+     | IsNul ->
+       (((fun p -> 2. *. p) s),
+         (sub_mask (g (f 1.)) ((fun p -> 2. *. p) ((fun p -> 2. *. p) 1.))))
+     | IsPos r ->
+       let s' = (fun p -> 1. +. (2. *. p)) ((fun p -> 2. *. p) s) in
+       let r' = g (f r) in
+       if leb s' r'
+       then (((fun p -> 1. +. (2. *. p)) s), (sub_mask r' s'))
+       else (((fun p -> 2. *. p) s), (IsPos r'))
+     | IsNeg ->
+       (((fun p -> 2. *. p) s),
+         (sub_mask (g (f 1.)) ((fun p -> 2. *. p) ((fun p -> 2. *. p) 1.)))))
+  
+  (** val sqrtrem : float -> float * mask **)
+  
+  let rec sqrtrem p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p1 ->
+        sqrtrem_step (fun x -> (fun p -> 1. +. (2. *. p)) x) (fun x ->
+          (fun p -> 1. +. (2. *. p)) x) (sqrtrem p1))
+        (fun p1 ->
+        sqrtrem_step (fun x -> (fun p -> 2. *. p) x) (fun x ->
+          (fun p -> 1. +. (2. *. p)) x) (sqrtrem p1))
+        (fun _ -> (1., (IsPos ((fun p -> 2. *. p)
+        1.))))
+        p0)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p1 ->
+        sqrtrem_step (fun x -> (fun p -> 1. +. (2. *. p)) x) (fun x ->
+          (fun p -> 2. *. p) x) (sqrtrem p1))
+        (fun p1 ->
+        sqrtrem_step (fun x -> (fun p -> 2. *. p) x) (fun x ->
+          (fun p -> 2. *. p) x) (sqrtrem p1))
+        (fun _ -> (1., (IsPos
+        1.)))
+        p0)
+      (fun _ -> (1.,
+      IsNul))
+      p
+  
+  (** val sqrt : float -> float **)
+  
+  let sqrt p =
+    fst (sqrtrem p)
+  
+  (** val gcdn : int -> float -> float -> float **)
+  
+  let rec gcdn n a b =
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      1.)
+      (fun n0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun a' ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun b' ->
+          match compare a' b' with
+          | Eq -> a
+          | Lt -> gcdn n0 (sub b' a') a
+          | Gt -> gcdn n0 (sub a' b') b)
+          (fun b0 ->
+          gcdn n0 a b0)
+          (fun _ ->
+          1.)
+          b)
+        (fun a0 ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun p ->
+          gcdn n0 a0 b)
+          (fun b0 -> (fun p -> 2. *. p)
+          (gcdn n0 a0 b0))
+          (fun _ ->
+          1.)
+          b)
+        (fun _ ->
+        1.)
+        a)
+      n
+  
+  (** val gcd : float -> float -> float **)
+  
+  let gcd a b =
+    gcdn (plus (size_nat a) (size_nat b)) a b
+  
+  (** val ggcdn : int -> float -> float -> float * (float * float) **)
+  
+  let rec ggcdn n a b =
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ -> (1., (a,
+      b)))
+      (fun n0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun a' ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun b' ->
+          match compare a' b' with
+          | Eq -> (a, (1., 1.))
+          | Lt ->
+            let (g, p) = ggcdn n0 (sub b' a') a in
+            let (ba, aa) = p in (g, (aa, (add aa ((fun p -> 2. *. p) ba))))
+          | Gt ->
+            let (g, p) = ggcdn n0 (sub a' b') b in
+            let (ab, bb) = p in (g, ((add bb ((fun p -> 2. *. p) ab)), bb)))
+          (fun b0 ->
+          let (g, p) = ggcdn n0 a b0 in
+          let (aa, bb) = p in (g, (aa, ((fun p -> 2. *. p) bb))))
+          (fun _ -> (1., (a,
+          1.)))
+          b)
+        (fun a0 ->
+        (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+          (fun p ->
+          let (g, p0) = ggcdn n0 a0 b in
+          let (aa, bb) = p0 in (g, (((fun p -> 2. *. p) aa), bb)))
+          (fun b0 ->
+          let (g, p) = ggcdn n0 a0 b0 in (((fun p -> 2. *. p) g), p))
+          (fun _ -> (1., (a,
+          1.)))
+          b)
+        (fun _ -> (1., (1.,
+        b)))
+        a)
+      n
+  
+  (** val ggcd : float -> float -> float * (float * float) **)
+  
+  let ggcd a b =
+    ggcdn (plus (size_nat a) (size_nat b)) a b
+  
+  (** val coq_Nsucc_double : float -> float **)
+  
+  let coq_Nsucc_double x =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      1.)
+      (fun p -> ((fun p -> 1. +. (2. *. p))
+      p))
+      x
+  
+  (** val coq_Ndouble : float -> float **)
+  
+  let coq_Ndouble n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      0.)
+      (fun p -> ((fun p -> 2. *. p)
+      p))
+      n
+  
+  (** val coq_lor : float -> float -> float **)
+  
+  let rec coq_lor p q =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 -> (fun p -> 1. +. (2. *. p))
+        (coq_lor p0 q0))
+        (fun q0 -> (fun p -> 1. +. (2. *. p))
+        (coq_lor p0 q0))
+        (fun _ ->
+        p)
+        q)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 -> (fun p -> 1. +. (2. *. p))
+        (coq_lor p0 q0))
+        (fun q0 -> (fun p -> 2. *. p)
+        (coq_lor p0 q0))
+        (fun _ -> (fun p -> 1. +. (2. *. p))
+        p0)
+        q)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        q)
+        (fun q0 -> (fun p -> 1. +. (2. *. p))
+        q0)
+        (fun _ ->
+        q)
+        q)
+      p
+  
+  (** val coq_land : float -> float -> float **)
+  
+  let rec coq_land p q =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Nsucc_double (coq_land p0 q0))
+        (fun q0 ->
+        coq_Ndouble (coq_land p0 q0))
+        (fun _ ->
+        1.)
+        q)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Ndouble (coq_land p0 q0))
+        (fun q0 ->
+        coq_Ndouble (coq_land p0 q0))
+        (fun _ ->
+        0.)
+        q)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        1.)
+        (fun q0 ->
+        0.)
+        (fun _ ->
+        1.)
+        q)
+      p
+  
+  (** val ldiff : float -> float -> float **)
+  
+  let rec ldiff p q =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Ndouble (ldiff p0 q0))
+        (fun q0 ->
+        coq_Nsucc_double (ldiff p0 q0))
+        (fun _ -> ((fun p -> 2. *. p)
+        p0))
+        q)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Ndouble (ldiff p0 q0))
+        (fun q0 ->
+        coq_Ndouble (ldiff p0 q0))
+        (fun _ ->
+        p)
+        q)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        0.)
+        (fun q0 ->
+        1.)
+        (fun _ ->
+        0.)
+        q)
+      p
+  
+  (** val coq_lxor : float -> float -> float **)
+  
+  let rec coq_lxor p q =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Ndouble (coq_lxor p0 q0))
+        (fun q0 ->
+        coq_Nsucc_double (coq_lxor p0 q0))
+        (fun _ -> ((fun p -> 2. *. p)
+        p0))
+        q)
+      (fun p0 ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 ->
+        coq_Nsucc_double (coq_lxor p0 q0))
+        (fun q0 ->
+        coq_Ndouble (coq_lxor p0 q0))
+        (fun _ -> ((fun p -> 1. +. (2. *. p))
+        p0))
+        q)
+      (fun _ ->
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun q0 -> ((fun p -> 2. *. p)
+        q0))
+        (fun q0 -> ((fun p -> 1. +. (2. *. p))
+        q0))
+        (fun _ ->
+        0.)
+        q)
+      p
+  
+  (** val shiftl_nat : float -> int -> float **)
+  
+  let shiftl_nat p n =
+    nat_iter n (fun x -> (fun p -> 2. *. p) x) p
+  
+  (** val shiftr_nat : float -> int -> float **)
+  
+  let shiftr_nat p n =
+    nat_iter n div2 p
+  
+  (** val shiftl : float -> float -> float **)
+  
+  let shiftl p n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      p)
+      (fun n0 ->
+      iter n0 (fun x -> (fun p -> 2. *. p) x) p)
+      n
+  
+  (** val shiftr : float -> float -> float **)
+  
+  let shiftr p n =
+    (fun f0 fp n -> if n=0. then f0 () else fp n)
+      (fun _ ->
+      p)
+      (fun n0 ->
+      iter n0 div2 p)
+      n
+  
+  (** val testbit_nat : float -> int -> bool **)
+  
+  let rec testbit_nat p =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 n ->
+      (fun fO fS n -> if n=0 then fO () else fS (n-1))
+        (fun _ ->
+        true)
+        (fun n' ->
+        testbit_nat p0 n')
+        n)
+      (fun p0 n ->
+      (fun fO fS n -> if n=0 then fO () else fS (n-1))
+        (fun _ ->
+        false)
+        (fun n' ->
+        testbit_nat p0 n')
+        n)
+      (fun _ n ->
+      (fun fO fS n -> if n=0 then fO () else fS (n-1))
+        (fun _ ->
+        true)
+        (fun n0 ->
+        false)
+        n)
+      p
+  
+  (** val testbit : float -> float -> bool **)
+  
+  let rec testbit p n =
+    (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+      (fun p0 ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        true)
+        (fun n0 ->
+        testbit p0 (pred_N n0))
+        n)
+      (fun p0 ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        false)
+        (fun n0 ->
+        testbit p0 (pred_N n0))
+        n)
+      (fun _ ->
+      (fun f0 fp n -> if n=0. then f0 () else fp n)
+        (fun _ ->
+        true)
+        (fun p0 ->
+        false)
+        n)
+      p
+  
+  (** val iter_op : ('a1 -> 'a1 -> 'a1) -> float -> 'a1 -> 'a1 **)
+  
+  let iter_op op =
+    let rec iter0 p a =
+      (fun f2p1 f2p f1 p ->
+if p <= 1. then f1 () else if mod_float p 2. = 0. then f2p (floor (p /. 2.)) else f2p1 (floor (p /. 2.)))
+        (fun p0 ->
+        op a (iter0 p0 (op a a)))
+        (fun p0 ->
+        iter0 p0 (op a a))
+        (fun _ ->
+        a)
+        p
+    in iter0
+  
+  (** val to_nat : float -> int **)
+  
+  let to_nat x =
+    iter_op plus x (Pervasives.succ 0)
+  
+  (** val of_nat : int -> float **)
+  
+  let rec of_nat n =
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      1.)
+      (fun x ->
+      (fun fO fS n -> if n=0 then fO () else fS (n-1))
+        (fun _ ->
+        1.)
+        (fun n0 ->
+        succ (of_nat x))
+        x)
+      n
+  
+  (** val of_succ_nat : int -> float **)
+  
+  let rec of_succ_nat n =
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      1.)
+      (fun x ->
+      succ (of_succ_nat x))
+      n
+ end
+
diff --git a/generator/tests/jsref/Bool0.ml b/generator/tests/jsref/Bool0.ml
new file mode 100644
index 0000000..22b7a4f
--- /dev/null
+++ b/generator/tests/jsref/Bool0.ml
@@ -0,0 +1,16 @@
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
+(** val eqb : bool -> bool -> bool **)
+
+let eqb b1 b2 =
+  if b1 then if b2 then true else false else if b2 then false else true
+
+type reflect =
+| ReflectT [@f]  (** Auto Generated Attributes **)
+| ReflectF [@f]  (** Auto Generated Attributes **)
+
+(** val iff_reflect : bool -> reflect **)
+
+let iff_reflect b =
+  (if b then (fun _ -> ReflectT) else (fun _ -> ReflectF)) __
+
diff --git a/generator/tests/jsref/Datatypes.ml b/generator/tests/jsref/Datatypes.ml
new file mode 100644
index 0000000..02c3844
--- /dev/null
+++ b/generator/tests/jsref/Datatypes.ml
@@ -0,0 +1,43 @@
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
+(** val negb : bool -> bool **)
+
+let negb = function
+| true -> false
+| false -> true
+
+(** val fst : ('a1 * 'a2) -> 'a1 **)
+
+let fst = function
+| (x, y) -> x
+
+(** val snd : ('a1 * 'a2) -> 'a2 **)
+
+let snd = function
+| (x, y) -> y
+
+type comparison =
+| Eq [@f]  (** Auto Generated Attributes **)
+| Lt [@f]  (** Auto Generated Attributes **)
+| Gt [@f]  (** Auto Generated Attributes **)
+
+type coq_CompareSpecT =
+| CompEqT [@f]  (** Auto Generated Attributes **)
+| CompLtT [@f]  (** Auto Generated Attributes **)
+| CompGtT [@f]  (** Auto Generated Attributes **)
+
+(** val coq_CompareSpec2Type : comparison -> coq_CompareSpecT **)
+
+let coq_CompareSpec2Type c =
+  (match c with
+   | Eq -> (fun _ -> CompEqT)
+   | Lt -> (fun _ -> CompLtT)
+   | Gt -> (fun _ -> CompGtT)) __
+
+type 'a coq_CompSpecT = coq_CompareSpecT
+
+(** val coq_CompSpec2Type : 'a1 -> 'a1 -> comparison -> 'a1 coq_CompSpecT **)
+
+let coq_CompSpec2Type x y c =
+  coq_CompareSpec2Type c
+
diff --git a/generator/tests/jsref/Fappli_IEEE.ml b/generator/tests/jsref/Fappli_IEEE.ml
new file mode 100644
index 0000000..e69de29
diff --git a/generator/tests/jsref/Fappli_IEEE_bits.ml b/generator/tests/jsref/Fappli_IEEE_bits.ml
new file mode 100644
index 0000000..cf507a2
--- /dev/null
+++ b/generator/tests/jsref/Fappli_IEEE_bits.ml
@@ -0,0 +1,2 @@
+type binary64 = float
+
diff --git a/generator/tests/jsref/JsCommon.ml b/generator/tests/jsref/JsCommon.ml
new file mode 100644
index 0000000..09c16b8
--- /dev/null
+++ b/generator/tests/jsref/JsCommon.ml
@@ -0,0 +1,596 @@
+open Datatypes
+open JsNumber
+open JsSyntax
+open JsSyntaxAux
+open LibList
+open LibNat
+open LibOption
+open LibStream
+open LibString
+open List0
+open Shared
+
+(** val res_overwrite_value_if_empty : resvalue -> res -> res **)
+
+let res_overwrite_value_if_empty rv r =
+  if resvalue_comparable r.res_value Coq_resvalue_empty
+  then res_with_value r rv
+  else r
+
+(** val res_label_in : res -> label_set -> bool **)
+
+let res_label_in r labs =
+  label_set_mem r.res_label labs
+
+(** val convert_literal_to_prim : literal -> prim **)
+
+let convert_literal_to_prim = function
+| Coq_literal_null -> Coq_prim_null
+| Coq_literal_bool b -> Coq_prim_bool b
+| Coq_literal_number n -> Coq_prim_number n
+| Coq_literal_string s -> Coq_prim_string s
+
+(** val type_of_prim : prim -> coq_type **)
+
+let type_of_prim = function
+| Coq_prim_undef -> Coq_type_undef
+| Coq_prim_null -> Coq_type_null
+| Coq_prim_bool b -> Coq_type_bool
+| Coq_prim_number n -> Coq_type_number
+| Coq_prim_string s -> Coq_type_string
+
+(** val type_of : value -> coq_type **)
+
+let type_of = function
+| Coq_value_prim w -> type_of_prim w
+| Coq_value_object o -> Coq_type_object
+
+(** val attributes_data_default : attributes_data **)
+
+let attributes_data_default =
+  { attributes_data_value = (Coq_value_prim Coq_prim_undef);
+    attributes_data_writable = false; attributes_data_enumerable = false;
+    attributes_data_configurable = false }
+
+(** val attributes_accessor_default : attributes_accessor **)
+
+let attributes_accessor_default =
+  { attributes_accessor_get = (Coq_value_prim Coq_prim_undef);
+    attributes_accessor_set = (Coq_value_prim Coq_prim_undef);
+    attributes_accessor_enumerable = false;
+    attributes_accessor_configurable = false }
+
+(** val attributes_accessor_of_attributes_data :
+    attributes_data -> attributes_accessor **)
+
+let attributes_accessor_of_attributes_data ad =
+  { attributes_accessor_get =
+    attributes_accessor_default.attributes_accessor_get;
+    attributes_accessor_set =
+    attributes_accessor_default.attributes_accessor_set;
+    attributes_accessor_enumerable = ad.attributes_data_enumerable;
+    attributes_accessor_configurable = ad.attributes_data_configurable }
+
+(** val attributes_data_of_attributes_accessor :
+    attributes_accessor -> attributes_data **)
+
+let attributes_data_of_attributes_accessor aa =
+  { attributes_data_value = attributes_data_default.attributes_data_value;
+    attributes_data_writable =
+    attributes_data_default.attributes_data_writable;
+    attributes_data_enumerable = aa.attributes_accessor_enumerable;
+    attributes_data_configurable = aa.attributes_accessor_configurable }
+
+(** val attributes_data_update :
+    attributes_data -> descriptor -> attributes_data **)
+
+let attributes_data_update ad desc =
+  { attributes_data_value =
+    (unsome_default ad.attributes_data_value desc.descriptor_value);
+    attributes_data_writable =
+    (unsome_default ad.attributes_data_writable desc.descriptor_writable);
+    attributes_data_enumerable =
+    (unsome_default ad.attributes_data_enumerable desc.descriptor_enumerable);
+    attributes_data_configurable =
+    (unsome_default ad.attributes_data_configurable
+      desc.descriptor_configurable) }
+
+(** val attributes_accessor_update :
+    attributes_accessor -> descriptor -> attributes_accessor **)
+
+let attributes_accessor_update aa desc =
+  { attributes_accessor_get =
+    (unsome_default aa.attributes_accessor_get desc.descriptor_get);
+    attributes_accessor_set =
+    (unsome_default aa.attributes_accessor_set desc.descriptor_set);
+    attributes_accessor_enumerable =
+    (unsome_default aa.attributes_accessor_enumerable
+      desc.descriptor_enumerable); attributes_accessor_configurable =
+    (unsome_default aa.attributes_accessor_configurable
+      desc.descriptor_configurable) }
+
+(** val attributes_update : attributes -> descriptor -> attributes **)
+
+let attributes_update a desc =
+  match a with
+  | Coq_attributes_data_of ad ->
+    Coq_attributes_data_of (attributes_data_update ad desc)
+  | Coq_attributes_accessor_of aa ->
+    Coq_attributes_accessor_of (attributes_accessor_update aa desc)
+
+(** val attributes_data_of_descriptor : descriptor -> attributes_data **)
+
+let attributes_data_of_descriptor desc =
+  attributes_data_update attributes_data_default desc
+
+(** val attributes_accessor_of_descriptor :
+    descriptor -> attributes_accessor **)
+
+let attributes_accessor_of_descriptor desc =
+  attributes_accessor_update attributes_accessor_default desc
+
+(** val descriptor_of_attributes : attributes -> descriptor **)
+
+let descriptor_of_attributes = function
+| Coq_attributes_data_of ad ->
+  { descriptor_value = (Some ad.attributes_data_value); descriptor_writable =
+    (Some ad.attributes_data_writable); descriptor_get = None;
+    descriptor_set = None; descriptor_enumerable = (Some
+    ad.attributes_data_enumerable); descriptor_configurable = (Some
+    ad.attributes_data_configurable) }
+| Coq_attributes_accessor_of aa ->
+  { descriptor_value = None; descriptor_writable = None; descriptor_get =
+    (Some aa.attributes_accessor_get); descriptor_set = (Some
+    aa.attributes_accessor_set); descriptor_enumerable = (Some
+    aa.attributes_accessor_enumerable); descriptor_configurable = (Some
+    aa.attributes_accessor_configurable) }
+
+(** val attributes_configurable : attributes -> bool **)
+
+let attributes_configurable = function
+| Coq_attributes_data_of ad -> ad.attributes_data_configurable
+| Coq_attributes_accessor_of aa -> aa.attributes_accessor_configurable
+
+(** val attributes_enumerable : attributes -> bool **)
+
+let attributes_enumerable = function
+| Coq_attributes_data_of ad -> ad.attributes_data_enumerable
+| Coq_attributes_accessor_of aa -> aa.attributes_accessor_enumerable
+
+(** val state_with_object_heap :
+    state -> (object_loc, coq_object) Heap.heap -> state **)
+
+let state_with_object_heap s new_object_heap =
+  let { state_object_heap = old_object_heap; state_env_record_heap =
+    env_heap; state_fresh_locations = fresh_locs; state_event_list =
+    ev_list } = s
+  in
+  { state_object_heap = new_object_heap; state_env_record_heap = env_heap;
+  state_fresh_locations = fresh_locs; state_event_list = ev_list }
+
+(** val state_map_object_heap :
+    state -> ((object_loc, coq_object) Heap.heap -> (object_loc, coq_object)
+    Heap.heap) -> state **)
+
+let state_map_object_heap s f =
+  state_with_object_heap s (f s.state_object_heap)
+
+(** val object_write : state -> object_loc -> coq_object -> state **)
+
+let object_write s l o =
+  state_map_object_heap s (fun h -> Heap.write h l o)
+
+(** val object_alloc : state -> coq_object -> object_loc * state **)
+
+let object_alloc s o =
+  let { state_object_heap = cells; state_env_record_heap = bindings;
+    state_fresh_locations = state_fresh_locations0; state_event_list =
+    ev_list } = s
+  in
+  let Coq_stream_intro (n, alloc) = Lazy.force state_fresh_locations0 in
+  let l = Coq_object_loc_normal n in
+  (l,
+  (object_write { state_object_heap = cells; state_env_record_heap =
+    bindings; state_fresh_locations = alloc; state_event_list = ev_list } l
+    o))
+
+(** val object_map_properties :
+    coq_object -> (object_properties_type -> object_properties_type) ->
+    coq_object **)
+
+let object_map_properties o f =
+  object_with_properties o (f o.object_properties_)
+
+(** val object_new : value -> class_name -> coq_object **)
+
+let object_new vproto sclass =
+  object_create vproto sclass true Heap.empty
+
+(** val attributes_writable : attributes -> bool **)
+
+let attributes_writable = function
+| Coq_attributes_data_of ad -> ad.attributes_data_writable
+| Coq_attributes_accessor_of aa -> false
+
+(** val attributes_data_intro_constant : value -> attributes_data **)
+
+let attributes_data_intro_constant v =
+  { attributes_data_value = v; attributes_data_writable = false;
+    attributes_data_enumerable = false; attributes_data_configurable =
+    false }
+
+(** val attributes_data_intro_all_true : value -> attributes_data **)
+
+let attributes_data_intro_all_true v =
+  { attributes_data_value = v; attributes_data_writable = true;
+    attributes_data_enumerable = true; attributes_data_configurable = true }
+
+(** val descriptor_intro_data :
+    value -> bool -> bool -> bool -> descriptor **)
+
+let descriptor_intro_data v bw be bc =
+  { descriptor_value = (Some v); descriptor_writable = (Some bw);
+    descriptor_get = None; descriptor_set = None; descriptor_enumerable =
+    (Some be); descriptor_configurable = (Some bc) }
+
+(** val descriptor_intro_empty : descriptor **)
+
+let descriptor_intro_empty =
+  { descriptor_value = None; descriptor_writable = None; descriptor_get =
+    None; descriptor_set = None; descriptor_enumerable = None;
+    descriptor_configurable = None }
+
+type ref_kind =
+| Coq_ref_kind_null [@f]  (** Auto Generated Attributes **)
+| Coq_ref_kind_undef [@f]  (** Auto Generated Attributes **)
+| Coq_ref_kind_primitive_base [@f]  (** Auto Generated Attributes **)
+| Coq_ref_kind_object [@f]  (** Auto Generated Attributes **)
+| Coq_ref_kind_env_record [@f]  (** Auto Generated Attributes **)
+
+(** val ref_kind_of : ref -> ref_kind **)
+
+let ref_kind_of r =
+  match r.ref_base with
+  | Coq_ref_base_type_value v ->
+    (match v with
+     | Coq_value_prim w ->
+       (match w with
+        | Coq_prim_undef -> Coq_ref_kind_undef
+        | Coq_prim_null -> Coq_ref_kind_null
+        | Coq_prim_bool b -> Coq_ref_kind_primitive_base
+        | Coq_prim_number n -> Coq_ref_kind_primitive_base
+        | Coq_prim_string s -> Coq_ref_kind_primitive_base)
+     | Coq_value_object o -> Coq_ref_kind_object)
+  | Coq_ref_base_type_env_loc l -> Coq_ref_kind_env_record
+
+(** val ref_create_value : value -> prop_name -> bool -> ref **)
+
+let ref_create_value v x strict =
+  { ref_base = (Coq_ref_base_type_value v); ref_name = x; ref_strict =
+    strict }
+
+(** val ref_create_env_loc : env_loc -> prop_name -> bool -> ref **)
+
+let ref_create_env_loc l x strict =
+  { ref_base = (Coq_ref_base_type_env_loc l); ref_name = x; ref_strict =
+    strict }
+
+(** val mutability_of_bool : bool -> mutability **)
+
+let mutability_of_bool = function
+| true -> Coq_mutability_deletable
+| false -> Coq_mutability_nondeletable
+
+(** val state_with_env_record_heap :
+    state -> (env_loc, env_record) Heap.heap -> state **)
+
+let state_with_env_record_heap s new_env_heap =
+  let { state_object_heap = object_heap; state_env_record_heap =
+    old_env_heap; state_fresh_locations = fresh_locs; state_event_list =
+    ev_list } = s
+  in
+  { state_object_heap = object_heap; state_env_record_heap = new_env_heap;
+  state_fresh_locations = fresh_locs; state_event_list = ev_list }
+
+(** val state_map_env_record_heap :
+    state -> ((env_loc, env_record) Heap.heap -> (env_loc, env_record)
+    Heap.heap) -> state **)
+
+let state_map_env_record_heap s f =
+  state_with_env_record_heap s (f s.state_env_record_heap)
+
+(** val env_record_write : state -> env_loc -> env_record -> state **)
+
+let env_record_write s l e =
+  state_map_env_record_heap s (fun h -> Heap.write h l e)
+
+(** val env_record_alloc : state -> env_record -> int * state **)
+
+let env_record_alloc s e =
+  let { state_object_heap = cells; state_env_record_heap = bindings;
+    state_fresh_locations = state_fresh_locations0; state_event_list =
+    ev_list } = s
+  in
+  let Coq_stream_intro (l, alloc) = Lazy.force state_fresh_locations0 in
+  let bindings' = Heap.write bindings l e in
+  (l, { state_object_heap = cells; state_env_record_heap = bindings';
+  state_fresh_locations = alloc; state_event_list = ev_list })
+
+(** val provide_this_true : provide_this_flag **)
+
+let provide_this_true =
+  true
+
+(** val provide_this_false : provide_this_flag **)
+
+let provide_this_false =
+  false
+
+(** val env_record_object_default : object_loc -> env_record **)
+
+let env_record_object_default l =
+  Coq_env_record_object (l, provide_this_false)
+
+(** val decl_env_record_empty : decl_env_record **)
+
+let decl_env_record_empty =
+  Heap.empty
+
+(** val decl_env_record_write :
+    decl_env_record -> prop_name -> mutability -> value -> decl_env_record **)
+
+let decl_env_record_write ed x mu v =
+  Heap.write ed x (mu, v)
+
+(** val decl_env_record_rem :
+    decl_env_record -> prop_name -> decl_env_record **)
+
+let decl_env_record_rem ed x =
+  Heap.rem string_comparable ed x
+
+(** val env_record_write_decl_env :
+    state -> env_loc -> prop_name -> mutability -> value -> state **)
+
+let env_record_write_decl_env s l x mu v =
+  match Heap.read nat_comparable s.state_env_record_heap l with
+  | Coq_env_record_decl ed ->
+    let env' = decl_env_record_write ed x mu v in
+    env_record_write s l (Coq_env_record_decl env')
+  | Coq_env_record_object (o, p) -> s
+
+(** val lexical_env_alloc :
+    state -> int list -> env_record -> int list * state **)
+
+let lexical_env_alloc s lex e =
+  let (l, s') = env_record_alloc s e in let lex' = l :: lex in (lex', s')
+
+(** val lexical_env_alloc_decl : state -> int list -> int list * state **)
+
+let lexical_env_alloc_decl s lex =
+  lexical_env_alloc s lex (Coq_env_record_decl decl_env_record_empty)
+
+(** val lexical_env_alloc_object :
+    state -> int list -> object_loc -> provide_this_flag -> int list * state **)
+
+let lexical_env_alloc_object s lex l pt =
+  lexical_env_alloc s lex (Coq_env_record_object (l, pt))
+
+(** val execution_ctx_intro_same :
+    lexical_env -> value -> strictness_flag -> execution_ctx **)
+
+let execution_ctx_intro_same x lthis strict =
+  { execution_ctx_lexical_env = x; execution_ctx_variable_env = x;
+    execution_ctx_this_binding = lthis; execution_ctx_strict = strict }
+
+(** val execution_ctx_with_lex :
+    execution_ctx -> lexical_env -> execution_ctx **)
+
+let execution_ctx_with_lex c lex =
+  let { execution_ctx_lexical_env = x1; execution_ctx_variable_env = x2;
+    execution_ctx_this_binding = x3; execution_ctx_strict = x4 } = c
+  in
+  { execution_ctx_lexical_env = lex; execution_ctx_variable_env = x2;
+  execution_ctx_this_binding = x3; execution_ctx_strict = x4 }
+
+(** val execution_ctx_with_lex_same :
+    execution_ctx -> lexical_env -> execution_ctx **)
+
+let execution_ctx_with_lex_same c lex =
+  let { execution_ctx_lexical_env = x1; execution_ctx_variable_env = x2;
+    execution_ctx_this_binding = x3; execution_ctx_strict = x4 } = c
+  in
+  { execution_ctx_lexical_env = lex; execution_ctx_variable_env = lex;
+  execution_ctx_this_binding = x3; execution_ctx_strict = x4 }
+
+(** val lexical_env_initial : lexical_env **)
+
+let lexical_env_initial =
+  env_loc_global_env_record :: []
+
+(** val execution_ctx_initial : strictness_flag -> execution_ctx **)
+
+let execution_ctx_initial str =
+  { execution_ctx_lexical_env = lexical_env_initial;
+    execution_ctx_variable_env = lexical_env_initial;
+    execution_ctx_this_binding = (Coq_value_object (Coq_object_loc_prealloc
+    Coq_prealloc_global)); execution_ctx_strict = str }
+
+(** val element_funcdecl : element -> funcdecl list **)
+
+let element_funcdecl = function
+| Coq_element_stat s -> []
+| Coq_element_func_decl (name, args, bd) ->
+  { funcdecl_name = name; funcdecl_parameters = args; funcdecl_body =
+    bd } :: []
+
+(** val prog_funcdecl : prog -> funcdecl list **)
+
+let prog_funcdecl p =
+  concat (LibList.map element_funcdecl (prog_elements p))
+
+(** val stat_vardecl : stat -> char list list **)
+
+let rec stat_vardecl = function
+| Coq_stat_expr e -> []
+| Coq_stat_label (s0, s) -> stat_vardecl s
+| Coq_stat_block ts -> concat (map stat_vardecl ts)
+| Coq_stat_var_decl nes -> LibList.map fst nes
+| Coq_stat_if (e, s1, s2o) ->
+  append (stat_vardecl s1)
+    (unsome_default [] (LibOption.map stat_vardecl s2o))
+| Coq_stat_do_while (l, s, e) -> stat_vardecl s
+| Coq_stat_while (l, e, s) -> stat_vardecl s
+| Coq_stat_with (e, s) -> stat_vardecl s
+| Coq_stat_throw e -> []
+| Coq_stat_return o -> []
+| Coq_stat_break l -> []
+| Coq_stat_continue l -> []
+| Coq_stat_try (s, sco, sfo) ->
+  append (stat_vardecl s)
+    (append
+      (unsome_default []
+        (LibOption.map (fun sc -> stat_vardecl (snd sc)) sco))
+      (unsome_default [] (LibOption.map stat_vardecl sfo)))
+| Coq_stat_for (l, o, o0, o1, s) -> stat_vardecl s
+| Coq_stat_for_var (l, nes, o, o0, s) ->
+  append (LibList.map fst nes) (stat_vardecl s)
+| Coq_stat_for_in (l, e, e0, s) -> stat_vardecl s
+| Coq_stat_for_in_var (l, str, o, e, s) -> str :: (stat_vardecl s)
+| Coq_stat_debugger -> []
+| Coq_stat_switch (l, e, sb) -> switchbody_vardecl sb
+
+(** val switchbody_vardecl : switchbody -> char list list **)
+
+and switchbody_vardecl = function
+| Coq_switchbody_nodefault scl -> concat (map switchclause_vardecl scl)
+| Coq_switchbody_withdefault (scl1, sl, scl2) ->
+  append (concat (map switchclause_vardecl scl1))
+    (append (concat (map stat_vardecl sl))
+      (concat (map switchclause_vardecl scl2)))
+
+(** val switchclause_vardecl : switchclause -> char list list **)
+
+and switchclause_vardecl = function
+| Coq_switchclause_intro (e, sl) -> concat (map stat_vardecl sl)
+
+(** val element_vardecl : element -> char list list **)
+
+let element_vardecl = function
+| Coq_element_stat t -> stat_vardecl t
+| Coq_element_func_decl (name, args, bd) -> []
+
+(** val prog_vardecl : prog -> char list list **)
+
+let prog_vardecl p =
+  concat (LibList.map element_vardecl (prog_elements p))
+
+type preftype =
+| Coq_preftype_number [@f]  (** Auto Generated Attributes **)
+| Coq_preftype_string [@f]  (** Auto Generated Attributes **)
+
+(** val method_of_preftype : preftype -> char list **)
+
+let method_of_preftype = function
+| Coq_preftype_number -> "valueOf"
+| Coq_preftype_string ->
+  "toString"
+
+(** val other_preftypes : preftype -> preftype **)
+
+let other_preftypes = function
+| Coq_preftype_number -> Coq_preftype_string
+| Coq_preftype_string -> Coq_preftype_number
+
+(** val throw_true : strictness_flag **)
+
+let throw_true =
+  true
+
+(** val throw_false : strictness_flag **)
+
+let throw_false =
+  false
+
+(** val throw_irrelevant : strictness_flag **)
+
+let throw_irrelevant =
+  false
+
+(** val add_one : number -> number **)
+
+let add_one n =
+  add n one
+
+(** val sub_one : number -> number **)
+
+let sub_one n =
+  sub n one
+
+(** val is_syntactic_eval : expr -> bool **)
+
+let is_syntactic_eval = function
+| Coq_expr_this -> false
+| Coq_expr_identifier s -> string_comparable s ("eval")
+| Coq_expr_literal l ->
+  (match l with
+   | Coq_literal_null -> false
+   | Coq_literal_bool b -> false
+   | Coq_literal_number n -> false
+   | Coq_literal_string s ->
+     string_comparable s ("eval"))
+| Coq_expr_object l -> false
+| Coq_expr_array l -> false
+| Coq_expr_function (o, l, f) -> false
+| Coq_expr_access (e0, e1) -> false
+| Coq_expr_member (e0, s) -> false
+| Coq_expr_new (e0, l) -> false
+| Coq_expr_call (e0, l) -> false
+| Coq_expr_unary_op (u, e0) -> false
+| Coq_expr_binary_op (e0, b, e1) -> false
+| Coq_expr_conditional (e0, e1, e2) -> false
+| Coq_expr_assign (e0, o, e1) -> false
+
+(** val elision_head_count : 'a1 option list -> int **)
+
+let rec elision_head_count = function
+| [] -> 0
+| o :: ol' ->
+  (match o with
+   | Some t -> 0
+   | None -> Pervasives.succ (elision_head_count ol'))
+
+(** val elision_head_remove : 'a1 option list -> 'a1 option list **)
+
+let rec elision_head_remove ol = match ol with
+| [] -> ol
+| o :: ol' ->
+  (match o with
+   | Some t -> ol
+   | None -> elision_head_remove ol')
+
+(** val elision_tail_count : 'a1 option list -> int **)
+
+let elision_tail_count ol =
+  elision_head_count (rev ol)
+
+(** val elision_tail_remove : 'a1 option list -> 'a1 option list **)
+
+let elision_tail_remove ol =
+  rev (elision_head_remove (rev ol))
+
+(** val parse_pickable : char list -> bool -> prog coq_Pickable_option **)
+
+let parse_pickable = (fun s strict ->
+    let str = String.concat "" (List.map (String.make 1) s) in
+    try
+      let parserExp = Parser_main.exp_from_string ~force_strict:strict str in
+      Some (JsSyntaxInfos.add_infos_prog strict
+        (Translate_syntax.exp_to_prog parserExp))
+    with
+    (* | Translate_syntax.CoqSyntaxDoesNotSupport _ -> assert false (* Temporary *) *)
+    | Parser.ParserFailure _ [@f]  (** Auto Generated Attributes **)
+    | Parser.InvalidArgument ->
+      prerr_string ("Warning:  Parser error on eval.  Input string:  \"" ^ str ^ "\"\n");
+      None
+  )
+
diff --git a/generator/tests/jsref/JsCommonAux.ml b/generator/tests/jsref/JsCommonAux.ml
new file mode 100644
index 0000000..0df384e
--- /dev/null
+++ b/generator/tests/jsref/JsCommonAux.ml
@@ -0,0 +1,413 @@
+open Datatypes
+open JsCommon
+open JsNumber
+open JsSyntax
+open JsSyntaxAux
+open LibList
+open LibNat
+open LibOption
+open LibReflect
+open LibString
+open Shared
+
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
+(** val if_some_then_same_dec :
+    'a1 option -> 'a1 option -> ('a1 -> 'a1 -> coq_Decidable) ->
+    coq_Decidable **)
+
+let if_some_then_same_dec x y d =
+  match x with
+  | Some a ->
+    (match y with
+     | Some a0 -> d a0 a
+     | None -> true_decidable)
+  | None ->
+    (match y with
+     | Some a -> false_decidable
+     | None -> true_decidable)
+
+(** val same_value_dec : value -> value -> coq_Decidable **)
+
+let same_value_dec v1 v2 =
+  let h0 = not_decidable (type_comparable (type_of v1) (type_of v2)) in
+  (if h0
+   then (fun _ -> false_decidable)
+   else (fun _ ->
+          let t = type_of v1 in
+          (match t with
+           | Coq_type_undef -> (fun _ _ -> true_decidable)
+           | Coq_type_null -> (fun _ _ -> true_decidable)
+           | Coq_type_bool -> (fun _ _ -> value_comparable v1 v2)
+           | Coq_type_number ->
+             (fun _ _ ->
+               let h2 =
+                 and_decidable
+                   (value_comparable v1 (Coq_value_prim (Coq_prim_number
+                     nan)))
+                   (value_comparable v2 (Coq_value_prim (Coq_prim_number
+                     nan)))
+               in
+               (if h2
+                then (fun _ -> true_decidable)
+                else (fun _ ->
+                       let h3 =
+                         and_decidable
+                           (value_comparable v1 (Coq_value_prim
+                             (Coq_prim_number zero)))
+                           (value_comparable v2 (Coq_value_prim
+                             (Coq_prim_number neg_zero)))
+                       in
+                       (if h3
+                        then (fun _ -> false_decidable)
+                        else (fun _ ->
+                               let h4 =
+                                 and_decidable
+                                   (value_comparable v1 (Coq_value_prim
+                                     (Coq_prim_number neg_zero)))
+                                   (value_comparable v2 (Coq_value_prim
+                                     (Coq_prim_number zero)))
+                               in
+                               (if h4
+                                then (fun _ -> false_decidable)
+                                else (fun _ -> value_comparable v1 v2)) __))
+                         __)) __)
+           | Coq_type_string -> (fun _ _ -> value_comparable v1 v2)
+           | Coq_type_object -> (fun _ _ -> value_comparable v1 v2)) __ __))
+    __
+
+(** val attributes_data_compare :
+    attributes_data -> attributes_data -> bool **)
+
+let attributes_data_compare ad1 ad2 =
+  let { attributes_data_value = v1; attributes_data_writable = w1;
+    attributes_data_enumerable = e1; attributes_data_configurable = c1 } =
+    ad1
+  in
+  let { attributes_data_value = v2; attributes_data_writable = w2;
+    attributes_data_enumerable = e2; attributes_data_configurable = c2 } =
+    ad2
+  in
+  and_decidable (value_comparable v1 v2)
+    (and_decidable (bool_comparable w1 w2)
+      (and_decidable (bool_comparable e1 e2) (bool_comparable c1 c2)))
+
+(** val attributes_data_comparable : attributes_data coq_Comparable **)
+
+let attributes_data_comparable x y =
+  attributes_data_compare x y
+
+(** val attributes_accessor_compare :
+    attributes_accessor -> attributes_accessor -> bool **)
+
+let attributes_accessor_compare aa1 aa2 =
+  let { attributes_accessor_get = v1; attributes_accessor_set = w1;
+    attributes_accessor_enumerable = e1; attributes_accessor_configurable =
+    c1 } = aa1
+  in
+  let { attributes_accessor_get = v2; attributes_accessor_set = w2;
+    attributes_accessor_enumerable = e2; attributes_accessor_configurable =
+    c2 } = aa2
+  in
+  and_decidable (value_comparable v1 v2)
+    (and_decidable (value_comparable w1 w2)
+      (and_decidable (bool_comparable e1 e2) (bool_comparable c1 c2)))
+
+(** val attributes_accessor_comparable :
+    attributes_accessor coq_Comparable **)
+
+let attributes_accessor_comparable x y =
+  attributes_accessor_compare x y
+
+(** val attributes_compare : attributes -> attributes -> bool **)
+
+let attributes_compare a1 a2 =
+  match a1 with
+  | Coq_attributes_data_of ad1 ->
+    (match a2 with
+     | Coq_attributes_data_of ad2 -> attributes_data_comparable ad1 ad2
+     | Coq_attributes_accessor_of a -> false)
+  | Coq_attributes_accessor_of aa1 ->
+    (match a2 with
+     | Coq_attributes_data_of a -> false
+     | Coq_attributes_accessor_of aa2 ->
+       attributes_accessor_comparable aa1 aa2)
+
+(** val attributes_comparable : attributes coq_Comparable **)
+
+let attributes_comparable x y =
+  attributes_compare x y
+
+(** val full_descriptor_compare :
+    full_descriptor -> full_descriptor -> bool **)
+
+let full_descriptor_compare an1 an2 =
+  match an1 with
+  | Coq_full_descriptor_undef ->
+    (match an2 with
+     | Coq_full_descriptor_undef -> true
+     | Coq_full_descriptor_some a -> false)
+  | Coq_full_descriptor_some a1 ->
+    (match an2 with
+     | Coq_full_descriptor_undef -> false
+     | Coq_full_descriptor_some a2 -> attributes_comparable a1 a2)
+
+(** val full_descriptor_comparable : full_descriptor coq_Comparable **)
+
+let full_descriptor_comparable x y =
+  full_descriptor_compare x y
+
+(** val ref_kind_comparable : ref_kind coq_Comparable **)
+
+let ref_kind_comparable x y =
+  match x with
+  | Coq_ref_kind_null ->
+    (match y with
+     | Coq_ref_kind_null -> true_decidable
+     | Coq_ref_kind_undef -> false_decidable
+     | Coq_ref_kind_primitive_base -> false_decidable
+     | Coq_ref_kind_object -> false_decidable
+     | Coq_ref_kind_env_record -> false_decidable)
+  | Coq_ref_kind_undef ->
+    (match y with
+     | Coq_ref_kind_null -> false_decidable
+     | Coq_ref_kind_undef -> true_decidable
+     | Coq_ref_kind_primitive_base -> false_decidable
+     | Coq_ref_kind_object -> false_decidable
+     | Coq_ref_kind_env_record -> false_decidable)
+  | Coq_ref_kind_primitive_base ->
+    (match y with
+     | Coq_ref_kind_null -> false_decidable
+     | Coq_ref_kind_undef -> false_decidable
+     | Coq_ref_kind_primitive_base -> true_decidable
+     | Coq_ref_kind_object -> false_decidable
+     | Coq_ref_kind_env_record -> false_decidable)
+  | Coq_ref_kind_object ->
+    (match y with
+     | Coq_ref_kind_null -> false_decidable
+     | Coq_ref_kind_undef -> false_decidable
+     | Coq_ref_kind_primitive_base -> false_decidable
+     | Coq_ref_kind_object -> true_decidable
+     | Coq_ref_kind_env_record -> false_decidable)
+  | Coq_ref_kind_env_record ->
+    (match y with
+     | Coq_ref_kind_null -> false_decidable
+     | Coq_ref_kind_undef -> false_decidable
+     | Coq_ref_kind_primitive_base -> false_decidable
+     | Coq_ref_kind_object -> false_decidable
+     | Coq_ref_kind_env_record -> true_decidable)
+
+(** val object_binds_pickable_option :
+    state -> object_loc -> coq_object coq_Pickable_option **)
+
+let object_binds_pickable_option s l =
+  Heap.read_option object_loc_comparable s.state_object_heap l
+
+(** val env_record_binds_pickable_option :
+    state -> env_loc -> env_record coq_Pickable_option **)
+
+let env_record_binds_pickable_option s l =
+  Heap.read_option nat_comparable s.state_env_record_heap l
+
+(** val decl_env_record_pickable_option :
+    decl_env_record -> prop_name -> (mutability * value) coq_Pickable_option **)
+
+let decl_env_record_pickable_option ed x =
+  Heap.read_option string_comparable ed x
+
+(** val descriptor_is_data_dec : descriptor -> coq_Decidable **)
+
+let descriptor_is_data_dec desc =
+  not_decidable
+    (and_decidable
+      (option_comparable value_comparable desc.descriptor_value None)
+      (option_comparable bool_comparable desc.descriptor_writable None))
+
+(** val descriptor_is_accessor_dec : descriptor -> coq_Decidable **)
+
+let descriptor_is_accessor_dec desc =
+  not_decidable
+    (and_decidable
+      (option_comparable value_comparable desc.descriptor_get None)
+      (option_comparable value_comparable desc.descriptor_set None))
+
+(** val descriptor_is_generic_dec : descriptor -> coq_Decidable **)
+
+let descriptor_is_generic_dec desc =
+  and_decidable (not_decidable (descriptor_is_data_dec desc))
+    (not_decidable (descriptor_is_accessor_dec desc))
+
+(** val prepost_unary_op_dec : unary_op -> coq_Decidable **)
+
+let prepost_unary_op_dec = function
+| Coq_unary_op_delete -> false
+| Coq_unary_op_void -> false
+| Coq_unary_op_typeof -> false
+| Coq_unary_op_post_incr -> true
+| Coq_unary_op_post_decr -> true
+| Coq_unary_op_pre_incr -> true
+| Coq_unary_op_pre_decr -> true
+| Coq_unary_op_add -> false
+| Coq_unary_op_neg -> false
+| Coq_unary_op_bitwise_not -> false
+| Coq_unary_op_not -> false
+
+(** val attributes_is_data_dec : attributes -> coq_Decidable **)
+
+let attributes_is_data_dec = function
+| Coq_attributes_data_of a0 -> true_decidable
+| Coq_attributes_accessor_of a0 -> false_decidable
+
+(** val run_object_heap_map_properties :
+    state -> object_loc -> (object_properties_type -> object_properties_type)
+    -> state option **)
+
+let run_object_heap_map_properties s l f =
+  map (fun o -> object_write s l (object_map_properties o f))
+    (object_binds_pickable_option s l)
+
+(** val object_heap_map_properties_pickable_option :
+    state -> object_loc -> (object_properties_type -> object_properties_type)
+    -> state coq_Pickable_option **)
+
+let object_heap_map_properties_pickable_option s l f =
+  run_object_heap_map_properties s l f
+
+(** val descriptor_contains_dec :
+    descriptor -> descriptor -> coq_Decidable **)
+
+let descriptor_contains_dec desc1 desc2 =
+  let { descriptor_value = descriptor_value0; descriptor_writable =
+    descriptor_writable0; descriptor_get = descriptor_get0; descriptor_set =
+    descriptor_set0; descriptor_enumerable = descriptor_enumerable0;
+    descriptor_configurable = descriptor_configurable0 } = desc1
+  in
+  let { descriptor_value = descriptor_value1; descriptor_writable =
+    descriptor_writable1; descriptor_get = descriptor_get1; descriptor_set =
+    descriptor_set1; descriptor_enumerable = descriptor_enumerable1;
+    descriptor_configurable = descriptor_configurable1 } = desc2
+  in
+  and_decidable
+    (if_some_then_same_dec descriptor_value0 descriptor_value1 (fun u v ->
+      same_value_dec u v))
+    (and_decidable
+      (if_some_then_same_dec descriptor_writable0 descriptor_writable1
+        (fun u v -> bool_comparable u v))
+      (and_decidable
+        (if_some_then_same_dec descriptor_get0 descriptor_get1 (fun u v ->
+          same_value_dec u v))
+        (and_decidable
+          (if_some_then_same_dec descriptor_set0 descriptor_set1 (fun u v ->
+            same_value_dec u v))
+          (and_decidable
+            (if_some_then_same_dec descriptor_enumerable0
+              descriptor_enumerable1 (fun u v -> bool_comparable u v))
+            (if_some_then_same_dec descriptor_configurable0
+              descriptor_configurable1 (fun u v -> bool_comparable u v))))))
+
+(** val descriptor_enumerable_not_same_dec :
+    attributes -> descriptor -> coq_Decidable **)
+
+let descriptor_enumerable_not_same_dec a desc =
+  let o = desc.descriptor_enumerable in
+  (match o with
+   | Some b -> not_decidable (bool_comparable b (attributes_enumerable a))
+   | None -> false_decidable)
+
+(** val descriptor_value_not_same_dec :
+    attributes_data -> descriptor -> coq_Decidable **)
+
+let descriptor_value_not_same_dec ad desc =
+  let o = desc.descriptor_value in
+  (match o with
+   | Some v -> not_decidable (same_value_dec v ad.attributes_data_value)
+   | None -> false_decidable)
+
+(** val descriptor_get_not_same_dec :
+    attributes_accessor -> descriptor -> coq_Decidable **)
+
+let descriptor_get_not_same_dec aa desc =
+  let o = desc.descriptor_get in
+  (match o with
+   | Some v -> not_decidable (same_value_dec v aa.attributes_accessor_get)
+   | None -> false_decidable)
+
+(** val descriptor_set_not_same_dec :
+    attributes_accessor -> descriptor -> coq_Decidable **)
+
+let descriptor_set_not_same_dec aa desc =
+  let o = desc.descriptor_set in
+  (match o with
+   | Some v -> not_decidable (same_value_dec v aa.attributes_accessor_set)
+   | None -> false_decidable)
+
+(** val attributes_change_enumerable_on_non_configurable_dec :
+    attributes -> descriptor -> coq_Decidable **)
+
+let attributes_change_enumerable_on_non_configurable_dec a desc =
+  and_decidable (bool_comparable (attributes_configurable a) false)
+    (or_decidable
+      (option_comparable bool_comparable desc.descriptor_configurable (Some
+        true)) (descriptor_enumerable_not_same_dec a desc))
+
+(** val attributes_change_data_on_non_configurable_dec :
+    attributes_data -> descriptor -> coq_Decidable **)
+
+let attributes_change_data_on_non_configurable_dec ad desc =
+  and_decidable
+    (bool_comparable (attributes_configurable (Coq_attributes_data_of ad))
+      false)
+    (and_decidable (bool_comparable ad.attributes_data_writable false)
+      (or_decidable
+        (option_comparable bool_comparable desc.descriptor_writable (Some
+          true)) (descriptor_value_not_same_dec ad desc)))
+
+(** val attributes_change_accessor_on_non_configurable_dec :
+    attributes_accessor -> descriptor -> coq_Decidable **)
+
+let attributes_change_accessor_on_non_configurable_dec aa desc =
+  and_decidable
+    (bool_comparable
+      (attributes_configurable (Coq_attributes_accessor_of aa)) false)
+    (or_decidable (descriptor_get_not_same_dec aa desc)
+      (descriptor_set_not_same_dec aa desc))
+
+(** val run_function_get_error_case : state -> prop_name -> value -> bool **)
+
+let run_function_get_error_case s x = function
+| Coq_value_prim w -> false
+| Coq_value_object l ->
+  (&&)
+    (if string_comparable x ("caller")
+     then true
+     else false)
+    (option_case false (fun o ->
+      option_case false (fun bd -> funcbody_is_strict bd) o.object_code_)
+      (object_binds_pickable_option s l))
+
+(** val spec_function_get_error_case_dec :
+    state -> prop_name -> value -> coq_Decidable **)
+
+let spec_function_get_error_case_dec s x v =
+  run_function_get_error_case s x v
+
+(** val run_callable : state -> value -> call option option **)
+
+let run_callable s = function
+| Coq_value_prim w -> Some None
+| Coq_value_object l ->
+  option_case None (fun o -> Some o.object_call_)
+    (object_binds_pickable_option s l)
+
+(** val is_callable_dec : state -> value -> coq_Decidable **)
+
+let is_callable_dec s v =
+  option_case false (option_case false (fun x -> true)) (run_callable s v)
+
+(** val object_properties_keys_as_list_pickable_option :
+    state -> object_loc -> prop_name list coq_Pickable_option **)
+
+let object_properties_keys_as_list_pickable_option s l =
+  map (fun props -> LibList.map fst (Heap.to_list props))
+    (map object_properties_ (object_binds_pickable_option s l))
+
diff --git a/generator/tests/jsref/JsInit.ml b/generator/tests/jsref/JsInit.ml
new file mode 100644
index 0000000..ab615d4
--- /dev/null
+++ b/generator/tests/jsref/JsInit.ml
@@ -0,0 +1,1345 @@
+open JsCommon
+open JsNumber
+open JsPreliminary
+open JsSyntax
+open JsSyntaxAux
+open LibInt
+open LibStream
+
+(** val prop_attributes_for_global_object : value -> attributes_data **)
+
+let prop_attributes_for_global_object v =
+  { attributes_data_value = v; attributes_data_writable = true;
+    attributes_data_enumerable = false; attributes_data_configurable = true }
+
+(** val attrib_constant : value -> attributes_data **)
+
+let attrib_constant v =
+  { attributes_data_value = v; attributes_data_writable = false;
+    attributes_data_enumerable = false; attributes_data_configurable =
+    false }
+
+(** val object_create_builtin :
+    value -> class_name -> object_properties_type -> coq_object **)
+
+let object_create_builtin vproto sclass p =
+  object_create vproto sclass true p
+
+(** val object_create_prealloc_call_or_construct :
+    value -> object_properties_type -> coq_object **)
+
+let object_create_prealloc_call_or_construct length p =
+  let sclass = "Function" in
+  let p' =
+    Heap.write p ("length")
+      (Coq_attributes_data_of (attrib_constant length))
+  in
+  object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+    Coq_prealloc_function_proto)) sclass p'
+
+(** val object_create_prealloc_call :
+    prealloc -> value -> object_properties_type -> coq_object **)
+
+let object_create_prealloc_call fprealloc length p =
+  let o = object_create_prealloc_call_or_construct length p in
+  object_with_invokation o None (Some (Coq_call_prealloc fprealloc)) None
+
+(** val object_create_prealloc_constructor :
+    prealloc -> value -> object_properties_type -> coq_object **)
+
+let object_create_prealloc_constructor fprealloc length p =
+  let o = object_create_prealloc_call_or_construct length p in
+  object_with_invokation o (Some (Coq_construct_prealloc fprealloc)) (Some
+    (Coq_call_prealloc fprealloc)) (Some Coq_builtin_has_instance_function)
+
+(** val write_native :
+    object_properties_type -> prop_name -> value -> (prop_name, attributes)
+    Heap.heap **)
+
+let write_native p name v =
+  Heap.write p name (Coq_attributes_data_of
+    (prop_attributes_for_global_object v))
+
+(** val write_constant :
+    object_properties_type -> prop_name -> value -> (prop_name, attributes)
+    Heap.heap **)
+
+let write_constant p name value0 =
+  Heap.write p name (Coq_attributes_data_of (attrib_constant value0))
+
+(** val object_prealloc_global_proto : value **)
+
+let object_prealloc_global_proto = (Coq_value_prim Coq_prim_null)
+
+(** val object_prealloc_global_class : char list **)
+
+let object_prealloc_global_class = (
+  let rec aux s = function
+  | 0 -> []
+  | n -> let n' = n - 1 in
+    s.[n'] :: aux s n'
+  in let aux2 s =
+    List.rev (aux s (String.length s))
+  in aux2 "GlobalClass")
+
+(** val object_prealloc_global_properties :
+    (prop_name, attributes) Heap.heap **)
+
+let object_prealloc_global_properties =
+  let p =
+    write_constant Heap.empty ("NaN") (Coq_value_prim
+      (Coq_prim_number nan))
+  in
+  let p0 =
+    write_constant p
+      ("Infinity")
+      (Coq_value_prim (Coq_prim_number infinity))
+  in
+  let p1 =
+    write_constant p0
+      ("undefined")
+      (Coq_value_prim Coq_prim_undef)
+  in
+  let p2 =
+    write_native p1 ("eval") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_global_eval))
+  in
+  let p3 =
+    write_native p2
+      ("parseInt")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_global_parse_int))
+  in
+  let p4 =
+    write_native p3
+      ("parseFloat")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_global_parse_float))
+  in
+  let p5 =
+    write_native p4 ("isNaN") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_global_is_nan))
+  in
+  let p6 =
+    write_native p5
+      ("isFinite")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_global_is_finite))
+  in
+  let p7 =
+    write_native p6
+      ("decodeURI")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_global_decode_uri))
+  in
+  let p8 =
+    write_native p7
+      ("decodeURIComponent")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_global_decode_uri_component))
+  in
+  let p9 =
+    write_native p8
+      ("encodeURI")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_global_encode_uri))
+  in
+  let p10 =
+    write_native p9
+      ("encodeURIComponent")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_global_encode_uri_component))
+  in
+  let p11 =
+    write_native p10 ("Object")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_object))
+  in
+  let p12 =
+    write_native p11
+      ("Function")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_function))
+  in
+  let p13 =
+    write_native p12 ("Array") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_array))
+  in
+  let p14 =
+    write_native p13 ("String")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_string))
+  in
+  let p15 =
+    write_native p14 ("Boolean")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_bool))
+  in
+  let p16 =
+    write_native p15 ("Number")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_number))
+  in
+  let p17 =
+    write_native p16 ("Math") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_math))
+  in
+  let p18 =
+    write_native p17 ("Date") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_date))
+  in
+  let p19 =
+    write_native p18 ("RegExp")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_regexp))
+  in
+  let p20 =
+    write_native p19 ("Error") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_error))
+  in
+  let p21 =
+    write_native p20
+      ("EvalError")
+      (Coq_value_object (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_eval)))
+  in
+  let p22 =
+    write_native p21
+      ("RangeError")
+      (Coq_value_object (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_range)))
+  in
+  let p23 =
+    write_native p22
+      ("ReferenceError")
+      (Coq_value_object (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_ref)))
+  in
+  let p24 =
+    write_native p23
+      ("SyntaxError")
+      (Coq_value_object (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_syntax)))
+  in
+  let p25 =
+    write_native p24
+      ("TypeError")
+      (Coq_value_object (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_type)))
+  in
+  let p26 =
+    write_native p25
+      ("URIError")
+      (Coq_value_object (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_uri)))
+  in
+  write_native p26 ("JSON") (Coq_value_object
+    (Coq_object_loc_prealloc Coq_prealloc_json))
+
+(** val object_prealloc_global : coq_object **)
+
+let object_prealloc_global =
+  object_create_builtin object_prealloc_global_proto
+    object_prealloc_global_class object_prealloc_global_properties
+
+(** val global_eval_function_object : coq_object **)
+
+let global_eval_function_object =
+  object_create_prealloc_call Coq_prealloc_global_eval (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val global_parse_int_function_object : coq_object **)
+
+let global_parse_int_function_object =
+  object_create_prealloc_call Coq_prealloc_global_parse_int (Coq_value_prim
+    (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ (Pervasives.succ 0)))))) Heap.empty
+
+(** val global_parse_float_function_object : coq_object **)
+
+let global_parse_float_function_object =
+  object_create_prealloc_call Coq_prealloc_global_parse_float (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val global_is_nan_function_object : coq_object **)
+
+let global_is_nan_function_object =
+  object_create_prealloc_call Coq_prealloc_global_is_nan (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val global_is_finite_function_object : coq_object **)
+
+let global_is_finite_function_object =
+  object_create_prealloc_call Coq_prealloc_global_is_finite (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val global_decode_uri_function_object : coq_object **)
+
+let global_decode_uri_function_object =
+  object_create_prealloc_call Coq_prealloc_global_decode_uri (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val global_decode_uri_component_function_object : coq_object **)
+
+let global_decode_uri_component_function_object =
+  object_create_prealloc_call Coq_prealloc_global_decode_uri_component
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val global_encode_uri_function_object : coq_object **)
+
+let global_encode_uri_function_object =
+  object_create_prealloc_call Coq_prealloc_global_encode_uri (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val global_encode_uri_component_function_object : coq_object **)
+
+let global_encode_uri_component_function_object =
+  object_create_prealloc_call Coq_prealloc_global_encode_uri_component
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_prealloc_object : coq_object **)
+
+let object_prealloc_object =
+  let p =
+    write_constant Heap.empty
+      ("prototype")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_object_proto))
+  in
+  let p0 =
+    write_native p
+      ("getPrototypeOf")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_get_proto_of))
+  in
+  let p1 =
+    write_native p0
+      ("getOwnPropertyDescriptor")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_get_own_prop_descriptor))
+  in
+  let p2 =
+    write_native p1
+      ("getOwnPropertyNames")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_get_own_prop_name))
+  in
+  let p3 =
+    write_native p2 ("create")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_object_create))
+  in
+  let p4 =
+    write_native p3
+      ("defineProperty")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_define_prop))
+  in
+  let p5 =
+    write_native p4
+      ("defineProperties")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_define_props))
+  in
+  let p6 =
+    write_native p5 ("seal") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_object_seal))
+  in
+  let p7 =
+    write_native p6 ("freeze")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_object_freeze))
+  in
+  let p8 =
+    write_native p7
+      ("preventExtensions")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_prevent_extensions))
+  in
+  let p9 =
+    write_native p8
+      ("isSealed")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_is_sealed))
+  in
+  let p10 =
+    write_native p9
+      ("isFrozen")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_is_frozen))
+  in
+  let p11 =
+    write_native p10
+      ("isExtensible")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_is_extensible))
+  in
+  object_create_prealloc_constructor Coq_prealloc_object (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) p11
+
+(** val object_get_proto_of_function_object : coq_object **)
+
+let object_get_proto_of_function_object =
+  object_create_prealloc_call Coq_prealloc_object_get_proto_of
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_get_own_prop_descriptor_function_object : coq_object **)
+
+let object_get_own_prop_descriptor_function_object =
+  object_create_prealloc_call Coq_prealloc_object_get_own_prop_descriptor
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_get_own_prop_name_function_object : coq_object **)
+
+let object_get_own_prop_name_function_object =
+  object_create_prealloc_call Coq_prealloc_object_get_own_prop_name
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_create_function_object : coq_object **)
+
+let object_create_function_object =
+  object_create_prealloc_call Coq_prealloc_object_create (Coq_value_prim
+    (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ (Pervasives.succ 0)))))) Heap.empty
+
+(** val object_define_prop_function_object : coq_object **)
+
+let object_define_prop_function_object =
+  object_create_prealloc_call Coq_prealloc_object_define_prop (Coq_value_prim
+    (Coq_prim_number
+    (of_int
+      (my_Z_of_nat (Pervasives.succ (Pervasives.succ (Pervasives.succ 0)))))))
+    Heap.empty
+
+(** val object_define_props_function_object : coq_object **)
+
+let object_define_props_function_object =
+  object_create_prealloc_call Coq_prealloc_object_define_props
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ (Pervasives.succ 0)))))) Heap.empty
+
+(** val object_seal_function_object : coq_object **)
+
+let object_seal_function_object =
+  object_create_prealloc_call Coq_prealloc_object_seal (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_freeze_function_object : coq_object **)
+
+let object_freeze_function_object =
+  object_create_prealloc_call Coq_prealloc_object_freeze (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_prevent_extensions_function_object : coq_object **)
+
+let object_prevent_extensions_function_object =
+  object_create_prealloc_call Coq_prealloc_object_prevent_extensions
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_is_sealed_function_object : coq_object **)
+
+let object_is_sealed_function_object =
+  object_create_prealloc_call Coq_prealloc_object_is_sealed (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_is_frozen_function_object : coq_object **)
+
+let object_is_frozen_function_object =
+  object_create_prealloc_call Coq_prealloc_object_is_frozen (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_is_extensible_function_object : coq_object **)
+
+let object_is_extensible_function_object =
+  object_create_prealloc_call Coq_prealloc_object_is_extensible
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_prealloc_object_proto : coq_object **)
+
+let object_prealloc_object_proto =
+  let p =
+    write_native Heap.empty
+      ("constructor")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_object))
+  in
+  let p0 =
+    write_native p ("toString")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto_to_string))
+  in
+  let p1 =
+    write_native p0 ("valueOf")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto_value_of))
+  in
+  let p2 =
+    write_native p1
+      ("hasOwnProperty")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto_has_own_prop))
+  in
+  let p3 =
+    write_native p2
+      ("isPrototypeOf")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto_is_prototype_of))
+  in
+  let p4 =
+    write_native p3
+      ("propertyIsEnumerable")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto_prop_is_enumerable))
+  in
+  object_create_builtin (Coq_value_prim Coq_prim_null)
+    ("Object") p4
+
+(** val object_proto_to_string_function_object : coq_object **)
+
+let object_proto_to_string_function_object =
+  object_create_prealloc_call Coq_prealloc_object_proto_to_string
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val object_proto_value_of_function_object : coq_object **)
+
+let object_proto_value_of_function_object =
+  object_create_prealloc_call Coq_prealloc_object_proto_value_of
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val object_proto_has_own_prop_function_object : coq_object **)
+
+let object_proto_has_own_prop_function_object =
+  object_create_prealloc_call Coq_prealloc_object_proto_has_own_prop
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val object_proto_is_prototype_of_function_object : coq_object **)
+
+let object_proto_is_prototype_of_function_object =
+  object_create_prealloc_call Coq_prealloc_object_proto_is_prototype_of
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_proto_prop_is_enumerable_function_object : coq_object **)
+
+let object_proto_prop_is_enumerable_function_object =
+  object_create_prealloc_call Coq_prealloc_object_proto_prop_is_enumerable
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_prealloc_function : coq_object **)
+
+let object_prealloc_function =
+  let p =
+    write_constant Heap.empty
+      ("prototype")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_function_proto))
+  in
+  object_create_prealloc_constructor Coq_prealloc_function (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) p
+
+(** val object_prealloc_function_proto : coq_object **)
+
+let object_prealloc_function_proto =
+  let p =
+    write_native Heap.empty
+      ("constructor")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_function))
+  in
+  let p0 =
+    Heap.write p ("length")
+      (Coq_attributes_data_of
+      (attrib_constant (Coq_value_prim (Coq_prim_number
+        (of_int (my_Z_of_nat 0))))))
+  in
+  let p1 =
+    write_native p0
+      ("toString")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_function_proto_to_string))
+  in
+  let p2 =
+    write_native p1 ("apply") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_function_proto_apply))
+  in
+  let p3 =
+    write_native p2 ("call") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_function_proto_call))
+  in
+  let p4 =
+    write_native p3 ("bind") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_function_proto_bind))
+  in
+  let o =
+    object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto))
+      ("Function") p4
+  in
+  object_with_invokation o None (Some (Coq_call_prealloc
+    Coq_prealloc_function_proto)) None
+
+(** val function_proto_to_string_function_object : coq_object **)
+
+let function_proto_to_string_function_object =
+  object_create_prealloc_call Coq_prealloc_function_proto_to_string
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val function_proto_call_function_object : coq_object **)
+
+let function_proto_call_function_object =
+  object_create_prealloc_call Coq_prealloc_function_proto_call
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val function_proto_bind_function_object : coq_object **)
+
+let function_proto_bind_function_object =
+  object_create_prealloc_call Coq_prealloc_function_proto_bind
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val function_proto_apply_function_object : coq_object **)
+
+let function_proto_apply_function_object =
+  object_create_prealloc_call Coq_prealloc_function_proto_apply
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ (Pervasives.succ 0)))))) Heap.empty
+
+(** val object_prealloc_number : coq_object **)
+
+let object_prealloc_number =
+  let p =
+    write_constant Heap.empty
+      ("prototype")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_number_proto))
+  in
+  let p0 =
+    write_constant p ("NaN") (Coq_value_prim (Coq_prim_number
+      nan))
+  in
+  let p1 =
+    write_constant p0
+      ("NEGATIVE_INFINITY")
+      (Coq_value_prim (Coq_prim_number neg_infinity))
+  in
+  let p2 =
+    write_constant p1
+      ("POSITIVE_INFINITY")
+      (Coq_value_prim (Coq_prim_number infinity))
+  in
+  let p3 =
+    write_constant p2
+      ("MAX_VALUE")
+      (Coq_value_prim (Coq_prim_number max_value))
+  in
+  let p4 =
+    write_constant p3
+      ("MIN_VALUE")
+      (Coq_value_prim (Coq_prim_number min_value))
+  in
+  object_create_prealloc_constructor Coq_prealloc_number (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) p4
+
+(** val object_prealloc_number_proto : coq_object **)
+
+let object_prealloc_number_proto =
+  let p =
+    write_native Heap.empty
+      ("constructor")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_number))
+  in
+  let p0 =
+    write_native p ("toString")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_number_proto_to_string))
+  in
+  let p1 =
+    write_native p0 ("valueOf")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_number_proto_value_of))
+  in
+  let o =
+    object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto))
+      ("Number") p1
+  in
+  object_with_primitive_value o (Coq_value_prim (Coq_prim_number zero))
+
+(** val number_proto_to_string_function_object : coq_object **)
+
+let number_proto_to_string_function_object =
+  object_create_prealloc_call Coq_prealloc_number_proto_to_string
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val number_proto_value_of_function_object : coq_object **)
+
+let number_proto_value_of_function_object =
+  object_create_prealloc_call Coq_prealloc_number_proto_value_of
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val object_prealloc_array : coq_object **)
+
+let object_prealloc_array =
+  let p =
+    write_constant Heap.empty
+      ("prototype")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_array_proto))
+  in
+  let p0 =
+    write_native p ("isArray")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_array_is_array))
+  in
+  let p1 =
+    write_constant p0 ("length")
+      (Coq_value_prim (Coq_prim_number
+      (of_int (my_Z_of_nat (Pervasives.succ 0)))))
+  in
+  object_create_prealloc_constructor Coq_prealloc_array (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) p1
+
+(** val array_is_array_function_object : coq_object **)
+
+let array_is_array_function_object =
+  object_create_prealloc_call Coq_prealloc_array_is_array (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_prealloc_array_proto : coq_object **)
+
+let object_prealloc_array_proto =
+  let p =
+    write_native Heap.empty
+      ("constructor")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_array))
+  in
+  let p0 =
+    write_native p ("toString")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_array_proto_to_string))
+  in
+  let p1 =
+    write_native p0 ("join") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_array_proto_join))
+  in
+  let p2 =
+    write_native p1 ("pop") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_array_proto_pop))
+  in
+  let p3 =
+    write_native p2 ("push") (Coq_value_object
+      (Coq_object_loc_prealloc Coq_prealloc_array_proto_push))
+  in
+  let p4 =
+    write_constant p3 ("length")
+      (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0))))
+  in
+  object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+    Coq_prealloc_object_proto)) ("Array") p4
+
+(** val array_proto_pop_function_object : coq_object **)
+
+let array_proto_pop_function_object =
+  object_create_prealloc_call Coq_prealloc_array_proto_pop (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val array_proto_push_function_object : coq_object **)
+
+let array_proto_push_function_object =
+  object_create_prealloc_call Coq_prealloc_array_proto_push (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val array_proto_to_string_function_object : coq_object **)
+
+let array_proto_to_string_function_object =
+  object_create_prealloc_call Coq_prealloc_array_proto_to_string
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val array_proto_join_function_object : coq_object **)
+
+let array_proto_join_function_object =
+  object_create_prealloc_call Coq_prealloc_array_proto_join (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_prealloc_string : coq_object **)
+
+let object_prealloc_string =
+  let p =
+    write_constant Heap.empty
+      ("prototype")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_string_proto))
+  in
+  object_create_prealloc_constructor Coq_prealloc_string (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) p
+
+(** val object_prealloc_string_proto : coq_object **)
+
+let object_prealloc_string_proto =
+  let p =
+    write_native Heap.empty
+      ("constructor")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_string))
+  in
+  let p0 =
+    write_native p ("toString")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_string_proto_to_string))
+  in
+  let p1 =
+    write_native p0 ("valueOf")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_string_proto_value_of))
+  in
+  let o =
+    object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto))
+      ("String") p1
+  in
+  object_with_primitive_value o (Coq_value_prim (Coq_prim_string []))
+
+(** val string_proto_to_string_function_object : coq_object **)
+
+let string_proto_to_string_function_object =
+  object_create_prealloc_call Coq_prealloc_string_proto_to_string
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val string_proto_value_of_function_object : coq_object **)
+
+let string_proto_value_of_function_object =
+  object_create_prealloc_call Coq_prealloc_string_proto_value_of
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val object_prealloc_bool : coq_object **)
+
+let object_prealloc_bool =
+  let p =
+    write_constant Heap.empty
+      ("prototype")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_bool_proto))
+  in
+  object_create_prealloc_constructor Coq_prealloc_bool (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) p
+
+(** val object_prealloc_bool_proto : coq_object **)
+
+let object_prealloc_bool_proto =
+  let p =
+    write_native Heap.empty
+      ("constructor")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_bool))
+  in
+  let p0 =
+    write_native p ("toString")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_bool_proto_to_string))
+  in
+  let p1 =
+    write_native p0 ("valueOf")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_bool_proto_value_of))
+  in
+  let o =
+    object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto))
+      ("Boolean") p1
+  in
+  object_with_primitive_value o (Coq_value_prim (Coq_prim_bool false))
+
+(** val bool_proto_to_string_function_object : coq_object **)
+
+let bool_proto_to_string_function_object =
+  object_create_prealloc_call Coq_prealloc_bool_proto_to_string
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val bool_proto_value_of_function_object : coq_object **)
+
+let bool_proto_value_of_function_object =
+  object_create_prealloc_call Coq_prealloc_bool_proto_value_of
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val object_prealloc_math : coq_object **)
+
+let object_prealloc_math =
+  let p =
+    write_constant Heap.empty ("PI") (Coq_value_prim
+      (Coq_prim_number pi))
+  in
+  let p0 = write_constant p ("E") (Coq_value_prim (Coq_prim_number e)) in
+  let p1 =
+    write_constant p0 ("LN2") (Coq_value_prim
+      (Coq_prim_number ln2))
+  in
+  object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+    Coq_prealloc_object_proto)) ("Math") p1
+
+(** val object_prealloc_date : coq_object **)
+
+let object_prealloc_date =
+  object_create_prealloc_constructor Coq_prealloc_date (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_prealloc_regexp : coq_object **)
+
+let object_prealloc_regexp =
+  object_create_prealloc_constructor Coq_prealloc_regexp (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) Heap.empty
+
+(** val object_prealloc_error : coq_object **)
+
+let object_prealloc_error =
+  let p =
+    write_constant Heap.empty
+      ("prototype")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_error_proto))
+  in
+  object_create_prealloc_constructor Coq_prealloc_error (Coq_value_prim
+    (Coq_prim_number (of_int (my_Z_of_nat (Pervasives.succ 0))))) p
+
+(** val object_prealloc_error_proto : coq_object **)
+
+let object_prealloc_error_proto =
+  let p =
+    write_native Heap.empty
+      ("constructor")
+      (Coq_value_object (Coq_object_loc_prealloc Coq_prealloc_error))
+  in
+  let p0 =
+    write_native p ("name") (Coq_value_prim
+      (Coq_prim_string ("Error")))
+  in
+  let p1 =
+    write_native p0 ("message")
+      (Coq_value_prim (Coq_prim_string []))
+  in
+  let p2 =
+    write_native p1
+      ("toString")
+      (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_error_proto_to_string))
+  in
+  object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+    Coq_prealloc_object_proto)) ("Error") p2
+
+(** val error_proto_to_string_function_object : coq_object **)
+
+let error_proto_to_string_function_object =
+  object_create_prealloc_call Coq_prealloc_error_proto_to_string
+    (Coq_value_prim (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+
+(** val object_prealloc_native_error : native_error -> coq_object **)
+
+let object_prealloc_native_error ne =
+  let p =
+    write_constant Heap.empty
+      ("prototype")
+      (Coq_value_object (Coq_object_loc_prealloc
+      (Coq_prealloc_native_error_proto ne)))
+  in
+  object_create_prealloc_constructor (Coq_prealloc_native_error ne)
+    (Coq_value_prim (Coq_prim_number
+    (of_int (my_Z_of_nat (Pervasives.succ 0))))) p
+
+(** val object_prealloc_native_error_proto : native_error -> coq_object **)
+
+let object_prealloc_native_error_proto ne =
+  let p =
+    write_native Heap.empty
+      ("constructor")
+      (Coq_value_object (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      ne)))
+  in
+  let p0 =
+    write_native p ("name") (Coq_value_prim
+      (Coq_prim_string (string_of_native_error ne)))
+  in
+  let p1 =
+    write_native p0 ("message")
+      (Coq_value_prim (Coq_prim_string []))
+  in
+  object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+    Coq_prealloc_error_proto)) ("Error") p1
+
+(** val object_prealloc_json : coq_object **)
+
+let object_prealloc_json =
+  object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+    Coq_prealloc_object_proto)) ("JSON") Heap.empty
+
+(** val throw_type_error_object : coq_object **)
+
+let throw_type_error_object =
+  let o =
+    object_create_prealloc_call Coq_prealloc_throw_type_error (Coq_value_prim
+      (Coq_prim_number (of_int (my_Z_of_nat 0)))) Heap.empty
+  in
+  let o0 = object_with_scope o (Some lexical_env_initial) in
+  let o1 = object_with_formal_params o0 (Some []) in
+  object_set_extensible o1 false
+
+(** val object_heap_initial_function_objects_1 :
+    (object_loc, coq_object) Heap.heap -> (object_loc, coq_object) Heap.heap **)
+
+let object_heap_initial_function_objects_1 h =
+  let h0 =
+    Heap.write h (Coq_object_loc_prealloc Coq_prealloc_throw_type_error)
+      throw_type_error_object
+  in
+  let h1 =
+    Heap.write h0 (Coq_object_loc_prealloc Coq_prealloc_global_eval)
+      global_eval_function_object
+  in
+  let h2 =
+    Heap.write h1 (Coq_object_loc_prealloc Coq_prealloc_global_parse_int)
+      global_parse_int_function_object
+  in
+  let h3 =
+    Heap.write h2 (Coq_object_loc_prealloc Coq_prealloc_global_parse_float)
+      global_parse_float_function_object
+  in
+  let h4 =
+    Heap.write h3 (Coq_object_loc_prealloc Coq_prealloc_global_is_nan)
+      global_is_nan_function_object
+  in
+  let h5 =
+    Heap.write h4 (Coq_object_loc_prealloc Coq_prealloc_global_is_finite)
+      global_is_finite_function_object
+  in
+  let h6 =
+    Heap.write h5 (Coq_object_loc_prealloc Coq_prealloc_global_decode_uri)
+      global_decode_uri_function_object
+  in
+  let h7 =
+    Heap.write h6 (Coq_object_loc_prealloc
+      Coq_prealloc_global_decode_uri_component)
+      global_decode_uri_component_function_object
+  in
+  let h8 =
+    Heap.write h7 (Coq_object_loc_prealloc Coq_prealloc_global_encode_uri)
+      global_encode_uri_function_object
+  in
+  Heap.write h8 (Coq_object_loc_prealloc
+    Coq_prealloc_global_encode_uri_component)
+    global_encode_uri_component_function_object
+
+(** val object_heap_initial_function_objects_2 :
+    (object_loc, coq_object) Heap.heap -> (object_loc, coq_object) Heap.heap **)
+
+let object_heap_initial_function_objects_2 h =
+  let h0 = object_heap_initial_function_objects_1 h in
+  let h1 =
+    Heap.write h0 (Coq_object_loc_prealloc Coq_prealloc_object_get_proto_of)
+      object_get_proto_of_function_object
+  in
+  let h2 =
+    Heap.write h1 (Coq_object_loc_prealloc
+      Coq_prealloc_object_get_own_prop_descriptor)
+      object_get_own_prop_descriptor_function_object
+  in
+  let h3 =
+    Heap.write h2 (Coq_object_loc_prealloc
+      Coq_prealloc_object_get_own_prop_name)
+      object_get_own_prop_name_function_object
+  in
+  let h4 =
+    Heap.write h3 (Coq_object_loc_prealloc Coq_prealloc_object_create)
+      object_create_function_object
+  in
+  let h5 =
+    Heap.write h4 (Coq_object_loc_prealloc Coq_prealloc_object_define_prop)
+      object_define_prop_function_object
+  in
+  let h6 =
+    Heap.write h5 (Coq_object_loc_prealloc Coq_prealloc_object_define_props)
+      object_define_props_function_object
+  in
+  let h7 =
+    Heap.write h6 (Coq_object_loc_prealloc Coq_prealloc_object_seal)
+      object_seal_function_object
+  in
+  let h8 =
+    Heap.write h7 (Coq_object_loc_prealloc Coq_prealloc_object_freeze)
+      object_freeze_function_object
+  in
+  let h9 =
+    Heap.write h8 (Coq_object_loc_prealloc
+      Coq_prealloc_object_prevent_extensions)
+      object_prevent_extensions_function_object
+  in
+  let h10 =
+    Heap.write h9 (Coq_object_loc_prealloc Coq_prealloc_object_is_sealed)
+      object_is_sealed_function_object
+  in
+  let h11 =
+    Heap.write h10 (Coq_object_loc_prealloc Coq_prealloc_object_is_frozen)
+      object_is_frozen_function_object
+  in
+  Heap.write h11 (Coq_object_loc_prealloc Coq_prealloc_object_is_extensible)
+    object_is_extensible_function_object
+
+(** val object_heap_initial_function_objects_3 :
+    (object_loc, coq_object) Heap.heap -> (object_loc, coq_object) Heap.heap **)
+
+let object_heap_initial_function_objects_3 h =
+  let h0 = object_heap_initial_function_objects_2 h in
+  let h1 =
+    Heap.write h0 (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto_to_string)
+      object_proto_to_string_function_object
+  in
+  let h2 =
+    Heap.write h1 (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto_value_of)
+      object_proto_value_of_function_object
+  in
+  let h3 =
+    Heap.write h2 (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto_has_own_prop)
+      object_proto_has_own_prop_function_object
+  in
+  let h4 =
+    Heap.write h3 (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto_is_prototype_of)
+      object_proto_is_prototype_of_function_object
+  in
+  let h5 =
+    Heap.write h4 (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto_prop_is_enumerable)
+      object_proto_prop_is_enumerable_function_object
+  in
+  let h6 =
+    Heap.write h5 (Coq_object_loc_prealloc
+      Coq_prealloc_function_proto_to_string)
+      function_proto_to_string_function_object
+  in
+  let h7 =
+    Heap.write h6 (Coq_object_loc_prealloc Coq_prealloc_function_proto_call)
+      function_proto_call_function_object
+  in
+  let h8 =
+    Heap.write h7 (Coq_object_loc_prealloc Coq_prealloc_function_proto_bind)
+      function_proto_bind_function_object
+  in
+  Heap.write h8 (Coq_object_loc_prealloc Coq_prealloc_function_proto_apply)
+    function_proto_apply_function_object
+
+(** val object_heap_initial_function_objects_4 :
+    (object_loc, coq_object) Heap.heap -> (object_loc, coq_object) Heap.heap **)
+
+let object_heap_initial_function_objects_4 h =
+  let h0 = object_heap_initial_function_objects_3 h in
+  let h1 =
+    Heap.write h0 (Coq_object_loc_prealloc Coq_prealloc_array_is_array)
+      array_is_array_function_object
+  in
+  let h2 =
+    Heap.write h1 (Coq_object_loc_prealloc
+      Coq_prealloc_array_proto_to_string)
+      array_proto_to_string_function_object
+  in
+  let h3 =
+    Heap.write h2 (Coq_object_loc_prealloc Coq_prealloc_array_proto_join)
+      array_proto_join_function_object
+  in
+  let h4 =
+    Heap.write h3 (Coq_object_loc_prealloc Coq_prealloc_array_proto_pop)
+      array_proto_pop_function_object
+  in
+  let h5 =
+    Heap.write h4 (Coq_object_loc_prealloc Coq_prealloc_array_proto_push)
+      array_proto_push_function_object
+  in
+  let h6 =
+    Heap.write h5 (Coq_object_loc_prealloc
+      Coq_prealloc_string_proto_to_string)
+      string_proto_to_string_function_object
+  in
+  let h7 =
+    Heap.write h6 (Coq_object_loc_prealloc
+      Coq_prealloc_string_proto_value_of)
+      string_proto_value_of_function_object
+  in
+  let h8 =
+    Heap.write h7 (Coq_object_loc_prealloc Coq_prealloc_bool_proto_to_string)
+      bool_proto_to_string_function_object
+  in
+  Heap.write h8 (Coq_object_loc_prealloc Coq_prealloc_bool_proto_value_of)
+    bool_proto_value_of_function_object
+
+(** val object_heap_initial_function_objects :
+    (object_loc, coq_object) Heap.heap -> (object_loc, coq_object) Heap.heap **)
+
+let object_heap_initial_function_objects h =
+  let h0 = object_heap_initial_function_objects_4 h in
+  let h1 =
+    Heap.write h0 (Coq_object_loc_prealloc
+      Coq_prealloc_number_proto_to_string)
+      number_proto_to_string_function_object
+  in
+  let h2 =
+    Heap.write h1 (Coq_object_loc_prealloc
+      Coq_prealloc_number_proto_value_of)
+      number_proto_value_of_function_object
+  in
+  Heap.write h2 (Coq_object_loc_prealloc Coq_prealloc_error_proto_to_string)
+    error_proto_to_string_function_object
+
+(** val object_heap_initial : (object_loc, coq_object) Heap.heap **)
+
+let object_heap_initial =
+  let h =
+    Heap.write Heap.empty (Coq_object_loc_prealloc Coq_prealloc_global)
+      object_prealloc_global
+  in
+  let h0 =
+    Heap.write h (Coq_object_loc_prealloc Coq_prealloc_object)
+      object_prealloc_object
+  in
+  let h1 =
+    Heap.write h0 (Coq_object_loc_prealloc Coq_prealloc_object_proto)
+      object_prealloc_object_proto
+  in
+  let h2 =
+    Heap.write h1 (Coq_object_loc_prealloc Coq_prealloc_bool)
+      object_prealloc_bool
+  in
+  let h3 =
+    Heap.write h2 (Coq_object_loc_prealloc Coq_prealloc_bool_proto)
+      object_prealloc_bool_proto
+  in
+  let h4 =
+    Heap.write h3 (Coq_object_loc_prealloc Coq_prealloc_number)
+      object_prealloc_number
+  in
+  let h5 =
+    Heap.write h4 (Coq_object_loc_prealloc Coq_prealloc_number_proto)
+      object_prealloc_number_proto
+  in
+  let h6 =
+    Heap.write h5 (Coq_object_loc_prealloc Coq_prealloc_function)
+      object_prealloc_function
+  in
+  let h7 =
+    Heap.write h6 (Coq_object_loc_prealloc Coq_prealloc_function_proto)
+      object_prealloc_function_proto
+  in
+  let h8 =
+    Heap.write h7 (Coq_object_loc_prealloc Coq_prealloc_array)
+      object_prealloc_array
+  in
+  let h9 =
+    Heap.write h8 (Coq_object_loc_prealloc Coq_prealloc_array_proto)
+      object_prealloc_array_proto
+  in
+  let h10 =
+    Heap.write h9 (Coq_object_loc_prealloc Coq_prealloc_string)
+      object_prealloc_string
+  in
+  let h11 =
+    Heap.write h10 (Coq_object_loc_prealloc Coq_prealloc_string_proto)
+      object_prealloc_string_proto
+  in
+  let h12 =
+    Heap.write h11 (Coq_object_loc_prealloc Coq_prealloc_math)
+      object_prealloc_math
+  in
+  let h13 =
+    Heap.write h12 (Coq_object_loc_prealloc Coq_prealloc_date)
+      object_prealloc_date
+  in
+  let h14 =
+    Heap.write h13 (Coq_object_loc_prealloc Coq_prealloc_regexp)
+      object_prealloc_regexp
+  in
+  let h15 =
+    Heap.write h14 (Coq_object_loc_prealloc Coq_prealloc_error_proto)
+      object_prealloc_error_proto
+  in
+  let h16 =
+    Heap.write h15 (Coq_object_loc_prealloc (Coq_prealloc_native_error_proto
+      Coq_native_error_eval))
+      (object_prealloc_native_error_proto Coq_native_error_eval)
+  in
+  let h17 =
+    Heap.write h16 (Coq_object_loc_prealloc (Coq_prealloc_native_error_proto
+      Coq_native_error_range))
+      (object_prealloc_native_error_proto Coq_native_error_range)
+  in
+  let h18 =
+    Heap.write h17 (Coq_object_loc_prealloc (Coq_prealloc_native_error_proto
+      Coq_native_error_ref))
+      (object_prealloc_native_error_proto Coq_native_error_ref)
+  in
+  let h19 =
+    Heap.write h18 (Coq_object_loc_prealloc (Coq_prealloc_native_error_proto
+      Coq_native_error_syntax))
+      (object_prealloc_native_error_proto Coq_native_error_syntax)
+  in
+  let h20 =
+    Heap.write h19 (Coq_object_loc_prealloc (Coq_prealloc_native_error_proto
+      Coq_native_error_type))
+      (object_prealloc_native_error_proto Coq_native_error_type)
+  in
+  let h21 =
+    Heap.write h20 (Coq_object_loc_prealloc (Coq_prealloc_native_error_proto
+      Coq_native_error_uri))
+      (object_prealloc_native_error_proto Coq_native_error_uri)
+  in
+  let h22 =
+    Heap.write h21 (Coq_object_loc_prealloc Coq_prealloc_error)
+      object_prealloc_error
+  in
+  let h23 =
+    Heap.write h22 (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_eval))
+      (object_prealloc_native_error Coq_native_error_eval)
+  in
+  let h24 =
+    Heap.write h23 (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_range))
+      (object_prealloc_native_error Coq_native_error_range)
+  in
+  let h25 =
+    Heap.write h24 (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_ref))
+      (object_prealloc_native_error Coq_native_error_ref)
+  in
+  let h26 =
+    Heap.write h25 (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_syntax))
+      (object_prealloc_native_error Coq_native_error_syntax)
+  in
+  let h27 =
+    Heap.write h26 (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_type))
+      (object_prealloc_native_error Coq_native_error_type)
+  in
+  let h28 =
+    Heap.write h27 (Coq_object_loc_prealloc (Coq_prealloc_native_error
+      Coq_native_error_uri))
+      (object_prealloc_native_error Coq_native_error_uri)
+  in
+  let h29 =
+    Heap.write h28 (Coq_object_loc_prealloc Coq_prealloc_json)
+      object_prealloc_json
+  in
+  object_heap_initial_function_objects h29
+
+(** val env_record_heap_initial : (env_loc, env_record) Heap.heap **)
+
+let env_record_heap_initial =
+  Heap.write Heap.empty env_loc_global_env_record
+    (env_record_object_default (Coq_object_loc_prealloc Coq_prealloc_global))
+
+(** val all_locations : int -> int stream **)
+
+let rec all_locations k =
+  lazy (Coq_stream_intro (k, (all_locations (Pervasives.succ k))))
+
+(** val dummy_fresh_locations : int stream **)
+
+let dummy_fresh_locations =
+  all_locations (Pervasives.succ 0)
+
+(** val state_initial : state **)
+
+let state_initial =
+  { state_object_heap = object_heap_initial; state_env_record_heap =
+    env_record_heap_initial; state_fresh_locations = dummy_fresh_locations;
+    state_event_list = [] }
+
diff --git a/generator/tests/jsref/JsInterpreter.ml b/generator/tests/jsref/JsInterpreter.ml
new file mode 100644
index 0000000..9098c65
--- /dev/null
+++ b/generator/tests/jsref/JsInterpreter.ml
@@ -0,0 +1,6189 @@
+open BinInt
+open Datatypes
+open JsCommon
+open JsCommonAux
+open JsInit
+open JsInterpreterMonads
+open JsNumber
+open JsPreliminary
+open JsSyntax
+open JsSyntaxAux
+open JsSyntaxInfos
+open LibBool
+open LibFunc
+open LibInt
+open LibList
+open LibNat
+open LibOption
+open LibProd
+open LibReflect
+open LibString
+open LibTactics
+open List0
+open Shared
+open String0
+
+type __ = Obj.t
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
+(** val build_error : state -> value -> value -> result **)
+
+let build_error s vproto vmsg =
+  let o = object_new vproto ("Error") in
+  let (l, s') = object_alloc s o in
+  if value_comparable vmsg (Coq_value_prim Coq_prim_undef)
+  then result_out (Coq_out_ter (s', (res_val (Coq_value_object l))))
+  else (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+         ("Need [to_string] (this function shall be put in [runs_type].)")
+
+(** val run_error : state -> native_error -> 'a1 specres **)
+
+let run_error s ne =
+  if_object
+    (build_error s (Coq_value_object (Coq_object_loc_prealloc
+      (Coq_prealloc_native_error_proto ne))) (Coq_value_prim Coq_prim_undef))
+    (fun s' l -> Coq_result_some (Coq_specret_out (Coq_out_ter (s',
+    (res_throw (Coq_resvalue_value (Coq_value_object l)))))))
+
+(** val out_error_or_void :
+    state -> strictness_flag -> native_error -> result **)
+
+let out_error_or_void s str ne =
+  if str then run_error s ne else result_out (out_void s)
+
+(** val out_error_or_cst :
+    state -> strictness_flag -> native_error -> value -> result **)
+
+let out_error_or_cst s str ne v =
+  if str then run_error s ne else result_out (Coq_out_ter (s, (res_val v)))
+
+(** val run_object_method :
+    (coq_object -> 'a1) -> state -> object_loc -> 'a1 option **)
+
+let run_object_method proj s l =
+  LibOption.map proj (object_binds_pickable_option s l)
+
+let run_object_method proj s l =
+   let opt = object_binds_pickable_option s l in
+     begin match opt with
+       | None -> prerr_endline (Printf.sprintf "Warning: in run_object_method the location %s is unfetchable." (Prheap.prloc l))
+       | _ -> ()
+     end;
+     LibOption.map proj opt
+ 
+ (** val run_object_heap_set_extensible :
+    bool -> state -> object_loc -> state option **)
+
+let run_object_heap_set_extensible b s l =
+  LibOption.map (fun o -> object_write s l (object_set_extensible o b))
+    (object_binds_pickable_option s l)
+
+let run_object_heap_set_extensible b s l =
+   let opt = object_binds_pickable_option s l in
+     begin match opt with
+       | None -> prerr_endline (Printf.sprintf "Warning: in run_object_heap_set_extensible the location %s is unfetchable." (Prheap.prloc l))
+       | _ -> ()
+     end;
+     LibOption.map (fun o -> object_write s l (object_set_extensible o b)) opt
+ 
+ type runs_type = { runs_type_expr : (state -> execution_ctx -> expr ->
+                                    result);
+                   runs_type_stat : (state -> execution_ctx -> stat ->
+                                    result);
+                   runs_type_prog : (state -> execution_ctx -> prog ->
+                                    result);
+                   runs_type_call : (state -> execution_ctx -> object_loc ->
+                                    value -> value list -> result);
+                   runs_type_call_prealloc : (state -> execution_ctx ->
+                                             prealloc -> value -> value list
+                                             -> result);
+                   runs_type_construct : (state -> execution_ctx -> construct
+                                         -> object_loc -> value list ->
+                                         result);
+                   runs_type_function_has_instance : (state -> object_loc ->
+                                                     value -> result);
+                   runs_type_object_has_instance : (state -> execution_ctx ->
+                                                   builtin_has_instance ->
+                                                   object_loc -> value ->
+                                                   result);
+                   runs_type_get_args_for_apply : (state -> execution_ctx ->
+                                                  object_loc -> float ->
+                                                  float -> value list
+                                                  specres);
+                   runs_type_stat_while : (state -> execution_ctx -> resvalue
+                                          -> label_set -> expr -> stat ->
+                                          result);
+                   runs_type_stat_do_while : (state -> execution_ctx ->
+                                             resvalue -> label_set -> expr ->
+                                             stat -> result);
+                   runs_type_stat_for_loop : (state -> execution_ctx ->
+                                             label_set -> resvalue -> expr
+                                             option -> expr option -> stat ->
+                                             result);
+                   runs_type_object_delete : (state -> execution_ctx ->
+                                             object_loc -> prop_name -> bool
+                                             -> result);
+                   runs_type_object_get_own_prop : (state -> execution_ctx ->
+                                                   object_loc -> prop_name ->
+                                                   full_descriptor specres);
+                   runs_type_object_get_prop : (state -> execution_ctx ->
+                                               object_loc -> prop_name ->
+                                               full_descriptor specres);
+                   runs_type_object_get : (state -> execution_ctx ->
+                                          object_loc -> prop_name -> result);
+                   runs_type_object_proto_is_prototype_of : (state ->
+                                                            object_loc ->
+                                                            object_loc ->
+                                                            result);
+                   runs_type_object_put : (state -> execution_ctx ->
+                                          object_loc -> prop_name -> value ->
+                                          strictness_flag -> result);
+                   runs_type_equal : (state -> execution_ctx -> value ->
+                                     value -> result);
+                   runs_type_to_integer : (state -> execution_ctx -> value ->
+                                          result);
+                   runs_type_to_string : (state -> execution_ctx -> value ->
+                                         result);
+                   runs_type_array_join_elements : (state -> execution_ctx ->
+                                                   object_loc -> float ->
+                                                   float -> char list ->
+                                                   char list -> result);
+                   runs_type_array_element_list : (state -> execution_ctx ->
+                                                  object_loc -> expr option
+                                                  list -> float -> result);
+                   runs_type_object_define_own_prop_array_loop : (state ->
+                                                                 execution_ctx
+                                                                 ->
+                                                                 object_loc
+                                                                 -> float ->
+                                                                 float ->
+                                                                 descriptor
+                                                                 -> bool ->
+                                                                 bool ->
+                                                                 (state ->
+                                                                 prop_name ->
+                                                                 descriptor
+                                                                 ->
+                                                                 strictness_flag
+                                                                 -> __
+                                                                 specres) ->
+                                                                 result) }
+
+(** val runs_type_expr :
+    runs_type -> state -> execution_ctx -> expr -> result **)
+
+let runs_type_expr x = x.runs_type_expr
+
+(** val runs_type_stat :
+    runs_type -> state -> execution_ctx -> stat -> result **)
+
+let runs_type_stat x = x.runs_type_stat
+
+(** val runs_type_prog :
+    runs_type -> state -> execution_ctx -> prog -> result **)
+
+let runs_type_prog x = x.runs_type_prog
+
+(** val runs_type_call :
+    runs_type -> state -> execution_ctx -> object_loc -> value -> value list
+    -> result **)
+
+let runs_type_call x = x.runs_type_call
+
+(** val runs_type_call_prealloc :
+    runs_type -> state -> execution_ctx -> prealloc -> value -> value list ->
+    result **)
+
+let runs_type_call_prealloc x = x.runs_type_call_prealloc
+
+(** val runs_type_construct :
+    runs_type -> state -> execution_ctx -> construct -> object_loc -> value
+    list -> result **)
+
+let runs_type_construct x = x.runs_type_construct
+
+(** val runs_type_function_has_instance :
+    runs_type -> state -> object_loc -> value -> result **)
+
+let runs_type_function_has_instance x = x.runs_type_function_has_instance
+
+(** val runs_type_object_has_instance :
+    runs_type -> state -> execution_ctx -> builtin_has_instance -> object_loc
+    -> value -> result **)
+
+let runs_type_object_has_instance x = x.runs_type_object_has_instance
+
+(** val runs_type_get_args_for_apply :
+    runs_type -> state -> execution_ctx -> object_loc -> float -> float ->
+    value list specres **)
+
+let runs_type_get_args_for_apply x = x.runs_type_get_args_for_apply
+
+(** val runs_type_stat_while :
+    runs_type -> state -> execution_ctx -> resvalue -> label_set -> expr ->
+    stat -> result **)
+
+let runs_type_stat_while x = x.runs_type_stat_while
+
+(** val runs_type_stat_do_while :
+    runs_type -> state -> execution_ctx -> resvalue -> label_set -> expr ->
+    stat -> result **)
+
+let runs_type_stat_do_while x = x.runs_type_stat_do_while
+
+(** val runs_type_stat_for_loop :
+    runs_type -> state -> execution_ctx -> label_set -> resvalue -> expr
+    option -> expr option -> stat -> result **)
+
+let runs_type_stat_for_loop x = x.runs_type_stat_for_loop
+
+(** val runs_type_object_delete :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name -> bool ->
+    result **)
+
+let runs_type_object_delete x = x.runs_type_object_delete
+
+(** val runs_type_object_get_own_prop :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name ->
+    full_descriptor specres **)
+
+let runs_type_object_get_own_prop x = x.runs_type_object_get_own_prop
+
+(** val runs_type_object_get_prop :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name ->
+    full_descriptor specres **)
+
+let runs_type_object_get_prop x = x.runs_type_object_get_prop
+
+(** val runs_type_object_get :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name -> result **)
+
+let runs_type_object_get x = x.runs_type_object_get
+
+(** val runs_type_object_proto_is_prototype_of :
+    runs_type -> state -> object_loc -> object_loc -> result **)
+
+let runs_type_object_proto_is_prototype_of x = x.runs_type_object_proto_is_prototype_of
+
+(** val runs_type_object_put :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name -> value
+    -> strictness_flag -> result **)
+
+let runs_type_object_put x = x.runs_type_object_put
+
+(** val runs_type_equal :
+    runs_type -> state -> execution_ctx -> value -> value -> result **)
+
+let runs_type_equal x = x.runs_type_equal
+
+(** val runs_type_to_string :
+    runs_type -> state -> execution_ctx -> value -> result **)
+
+let runs_type_to_string x = x.runs_type_to_string
+
+(** val runs_type_array_join_elements :
+    runs_type -> state -> execution_ctx -> object_loc -> float -> float ->
+    char list -> char list -> result **)
+
+let runs_type_array_join_elements x = x.runs_type_array_join_elements
+
+(** val runs_type_array_element_list :
+    runs_type -> state -> execution_ctx -> object_loc -> expr option list ->
+    float -> result **)
+
+let runs_type_array_element_list x = x.runs_type_array_element_list
+
+(** val runs_type_object_define_own_prop_array_loop :
+    runs_type -> state -> execution_ctx -> object_loc -> float -> float ->
+    descriptor -> bool -> bool -> (state -> prop_name -> descriptor ->
+    strictness_flag -> __ specres) -> result **)
+
+let runs_type_object_define_own_prop_array_loop x = x.runs_type_object_define_own_prop_array_loop
+
+(** val object_has_prop :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name -> result **)
+
+let object_has_prop runs0 s c l x =
+  if_some (run_object_method object_has_prop_ s l) (fun b ->
+    let Coq_builtin_has_prop_default = b in
+    if_spec (runs0.runs_type_object_get_prop s c l x) (fun s1 d ->
+      res_ter s1
+        (res_val (Coq_value_prim (Coq_prim_bool
+          (not_decidable
+            (full_descriptor_comparable d Coq_full_descriptor_undef)))))))
+
+(** val object_get_builtin :
+    runs_type -> state -> execution_ctx -> builtin_get -> value -> object_loc
+    -> prop_name -> result **)
+
+let object_get_builtin runs0 s c b vthis l x =
+  let_binding (fun s0 l0 ->
+    if_spec (runs0.runs_type_object_get_prop s0 c l0 x) (fun s1 d ->
+      match d with
+      | Coq_full_descriptor_undef ->
+        res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+      | Coq_full_descriptor_some a ->
+        (match a with
+         | Coq_attributes_data_of ad ->
+           res_ter s1 (res_val ad.attributes_data_value)
+         | Coq_attributes_accessor_of aa ->
+           (match aa.attributes_accessor_get with
+            | Coq_value_prim p ->
+              (match p with
+               | Coq_prim_undef ->
+                 res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+               | Coq_prim_null -> Coq_result_impossible
+               | Coq_prim_bool b0 -> Coq_result_impossible
+               | Coq_prim_number n -> Coq_result_impossible
+               | Coq_prim_string s2 -> Coq_result_impossible)
+            | Coq_value_object lf -> runs0.runs_type_call s1 c lf vthis []))))
+    (fun default ->
+    let_binding (fun s0 ->
+      if_value (default s0 l) (fun s' v ->
+        if spec_function_get_error_case_dec s' x v
+        then run_error s' Coq_native_error_type
+        else res_ter s' (res_val v))) (fun function0 ->
+      match b with
+      | Coq_builtin_get_default -> default s l
+      | Coq_builtin_get_function -> function0 s
+      | Coq_builtin_get_args_obj ->
+        if_some (run_object_method object_parameter_map_ s l) (fun lmapo ->
+          if_some lmapo (fun lmap ->
+            if_spec (runs0.runs_type_object_get_own_prop s c lmap x)
+              (fun s0 d ->
+              match d with
+              | Coq_full_descriptor_undef -> function0 s0
+              | Coq_full_descriptor_some a ->
+                runs0.runs_type_object_get s0 c lmap x)))))
+
+(** val run_object_get :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name -> result **)
+
+let run_object_get runs0 s c l x =
+  if_some (run_object_method object_get_ s l) (fun b ->
+    object_get_builtin runs0 s c b (Coq_value_object l) l x)
+
+(** val run_object_get_prop :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name ->
+    full_descriptor specres **)
+
+let run_object_get_prop runs0 s c l x =
+  if_some (run_object_method object_get_prop_ s l) (fun b ->
+    let Coq_builtin_get_prop_default = b in
+    if_spec (runs0.runs_type_object_get_own_prop s c l x) (fun s1 d ->
+      if full_descriptor_comparable d Coq_full_descriptor_undef
+      then if_some (run_object_method object_proto_ s1 l) (fun proto ->
+             match proto with
+             | Coq_value_prim p ->
+               (match p with
+                | Coq_prim_undef ->
+                  (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                    s1
+                    ("Found a non-null primitive value as a prototype in [run_object_get_prop].")
+                | Coq_prim_null -> res_spec s1 Coq_full_descriptor_undef
+                | Coq_prim_bool b0 ->
+                  (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                    s1
+                    ("Found a non-null primitive value as a prototype in [run_object_get_prop].")
+                | Coq_prim_number n ->
+                  (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                    s1
+                    ("Found a non-null primitive value as a prototype in [run_object_get_prop].")
+                | Coq_prim_string s0 ->
+                  (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                    s1
+                    ("Found a non-null primitive value as a prototype in [run_object_get_prop]."))
+             | Coq_value_object lproto ->
+               runs0.runs_type_object_get_prop s1 c lproto x)
+      else res_spec s1 d))
+
+(** val object_proto_is_prototype_of :
+    runs_type -> state -> object_loc -> object_loc -> result **)
+
+let object_proto_is_prototype_of runs0 s l0 l =
+  if_some (run_object_method object_proto_ s l) (fun b ->
+    match b with
+    | Coq_value_prim p ->
+      (match p with
+       | Coq_prim_undef ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[run_object_method] returned a primitive in [object_proto_is_prototype_of_body].")
+       | Coq_prim_null ->
+         result_out (Coq_out_ter (s,
+           (res_val (Coq_value_prim (Coq_prim_bool false)))))
+       | Coq_prim_bool b0 ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[run_object_method] returned a primitive in [object_proto_is_prototype_of_body].")
+       | Coq_prim_number n ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[run_object_method] returned a primitive in [object_proto_is_prototype_of_body].")
+       | Coq_prim_string s0 ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[run_object_method] returned a primitive in [object_proto_is_prototype_of_body]."))
+    | Coq_value_object l' ->
+      if object_loc_comparable l' l0
+      then result_out (Coq_out_ter (s,
+             (res_val (Coq_value_prim (Coq_prim_bool true)))))
+      else runs0.runs_type_object_proto_is_prototype_of s l0 l')
+
+(** val object_default_value :
+    runs_type -> state -> execution_ctx -> object_loc -> preftype option ->
+    result **)
+
+let object_default_value runs0 s c l prefo =
+  if_some (run_object_method object_default_value_ s l) (fun b ->
+    let Coq_builtin_default_value_default = b in
+    let gpref = unsome_default Coq_preftype_number prefo in
+    let lpref = other_preftypes gpref in
+    let_binding (fun s' x k ->
+      if_value (run_object_get runs0 s' c l x) (fun s1 vfo ->
+        if_some (run_callable s1 vfo) (fun co ->
+          match co with
+          | Some b0 ->
+            if_object (result_out (Coq_out_ter (s1, (res_val vfo))))
+              (fun s2 lfunc ->
+              if_value
+                (runs0.runs_type_call s2 c lfunc (Coq_value_object l) [])
+                (fun s3 v ->
+                match v with
+                | Coq_value_prim w ->
+                  result_out (Coq_out_ter (s3, (res_val (Coq_value_prim w))))
+                | Coq_value_object l0 -> k s3))
+          | None -> k s1))) (fun sub0 ->
+      let_binding (method_of_preftype gpref) (fun gmeth ->
+        sub0 s gmeth (fun s' ->
+          let lmeth = method_of_preftype lpref in
+          sub0 s' lmeth (fun s'' -> run_error s'' Coq_native_error_type)))))
+
+(** val to_primitive :
+    runs_type -> state -> execution_ctx -> value -> preftype option -> result **)
+
+let to_primitive runs0 s c v prefo =
+  match v with
+  | Coq_value_prim w ->
+    result_out (Coq_out_ter (s, (res_val (Coq_value_prim w))))
+  | Coq_value_object l ->
+    if_prim (object_default_value runs0 s c l prefo) (fun s0 r ->
+      res_ter s0 (res_val (Coq_value_prim r)))
+
+(** val to_number :
+    runs_type -> state -> execution_ctx -> value -> result **)
+
+let to_number runs0 s c = function
+| Coq_value_prim w ->
+  result_out (Coq_out_ter (s,
+    (res_val (Coq_value_prim (Coq_prim_number (convert_prim_to_number w))))))
+| Coq_value_object l ->
+  if_prim
+    (to_primitive runs0 s c (Coq_value_object l) (Some Coq_preftype_number))
+    (fun s1 w ->
+    res_ter s1
+      (res_val (Coq_value_prim (Coq_prim_number (convert_prim_to_number w)))))
+
+(** val to_integer :
+    runs_type -> state -> execution_ctx -> value -> result **)
+
+let to_integer runs0 s c v =
+  if_number (to_number runs0 s c v) (fun s1 n ->
+    res_ter s1
+      (res_val (Coq_value_prim (Coq_prim_number
+        (convert_number_to_integer n)))))
+
+(** val to_int32 :
+    runs_type -> state -> execution_ctx -> value -> float specres **)
+
+let to_int32 runs0 s c v =
+  if_number (to_number runs0 s c v) (fun s' n -> res_spec s' (to_int32 n))
+
+(** val to_uint32 :
+    runs_type -> state -> execution_ctx -> value -> float specres **)
+
+let to_uint32 runs0 s c v =
+  if_number (to_number runs0 s c v) (fun s' n -> res_spec s' (to_uint32 n))
+
+(** val to_string :
+    runs_type -> state -> execution_ctx -> value -> result **)
+
+let to_string runs0 s c = function
+| Coq_value_prim w ->
+  result_out (Coq_out_ter (s,
+    (res_val (Coq_value_prim (Coq_prim_string (convert_prim_to_string w))))))
+| Coq_value_object l ->
+  if_prim
+    (to_primitive runs0 s c (Coq_value_object l) (Some Coq_preftype_string))
+    (fun s1 w ->
+    res_ter s1
+      (res_val (Coq_value_prim (Coq_prim_string (convert_prim_to_string w)))))
+
+(** val object_can_put :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name -> result **)
+
+let object_can_put runs0 s c l x =
+  if_some (run_object_method object_can_put_ s l) (fun b ->
+    let Coq_builtin_can_put_default = b in
+    if_spec (runs0.runs_type_object_get_own_prop s c l x) (fun s1 d ->
+      match d with
+      | Coq_full_descriptor_undef ->
+        if_some (run_object_method object_proto_ s1 l) (fun vproto ->
+          match vproto with
+          | Coq_value_prim p ->
+            (match p with
+             | Coq_prim_undef ->
+               (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                 s1
+                 ("Non-null primitive get as a prototype value in [object_can_put].")
+             | Coq_prim_null ->
+               if_some (run_object_method object_extensible_ s1 l) (fun b0 ->
+                 res_ter s1 (res_val (Coq_value_prim (Coq_prim_bool b0))))
+             | Coq_prim_bool b0 ->
+               (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                 s1
+                 ("Non-null primitive get as a prototype value in [object_can_put].")
+             | Coq_prim_number n ->
+               (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                 s1
+                 ("Non-null primitive get as a prototype value in [object_can_put].")
+             | Coq_prim_string s0 ->
+               (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                 s1
+                 ("Non-null primitive get as a prototype value in [object_can_put]."))
+          | Coq_value_object lproto ->
+            if_spec (run_object_get_prop runs0 s1 c lproto x) (fun s2 d' ->
+              match d' with
+              | Coq_full_descriptor_undef ->
+                if_some (run_object_method object_extensible_ s2 l)
+                  (fun b0 ->
+                  res_ter s2 (res_val (Coq_value_prim (Coq_prim_bool b0))))
+              | Coq_full_descriptor_some a ->
+                (match a with
+                 | Coq_attributes_data_of ad ->
+                   if_some (run_object_method object_extensible_ s2 l)
+                     (fun ext ->
+                     res_ter s2
+                       (if ext
+                        then res_val (Coq_value_prim (Coq_prim_bool
+                               ad.attributes_data_writable))
+                        else res_val (Coq_value_prim (Coq_prim_bool false))))
+                 | Coq_attributes_accessor_of aa ->
+                   res_ter s2
+                     (res_val (Coq_value_prim (Coq_prim_bool
+                       (not_decidable
+                         (value_comparable aa.attributes_accessor_set
+                           (Coq_value_prim Coq_prim_undef)))))))))
+      | Coq_full_descriptor_some a ->
+        (match a with
+         | Coq_attributes_data_of ad ->
+           res_ter s1
+             (res_val (Coq_value_prim (Coq_prim_bool
+               ad.attributes_data_writable)))
+         | Coq_attributes_accessor_of aa ->
+           res_ter s1
+             (res_val (Coq_value_prim (Coq_prim_bool
+               (not_decidable
+                 (value_comparable aa.attributes_accessor_set (Coq_value_prim
+                   Coq_prim_undef)))))))))
+
+(** val run_object_define_own_prop_array_loop :
+    runs_type -> state -> execution_ctx -> object_loc -> float -> float ->
+    descriptor -> bool -> bool -> (state -> prop_name -> descriptor ->
+    strictness_flag -> __ specres) -> result **)
+
+let run_object_define_own_prop_array_loop runs0 s c l newLen oldLen newLenDesc newWritable throw def =
+  if lt_int_decidable newLen oldLen
+  then let_binding (Z.sub oldLen 1.) (fun oldLen' ->
+         if_string
+           (to_string runs0 s c (Coq_value_prim (Coq_prim_number
+             (of_int oldLen')))) (fun s0 slen ->
+           if_bool (runs0.runs_type_object_delete s0 c l slen false)
+             (fun s1 deleteSucceeded ->
+             if not_decidable (bool_decidable deleteSucceeded)
+             then let_binding
+                    (descriptor_with_value newLenDesc (Some (Coq_value_prim
+                      (Coq_prim_number (of_int (Z.add oldLen' 1.))))))
+                    (fun newLenDesc0 ->
+                    let_binding
+                      (if not_decidable (bool_decidable newWritable)
+                       then descriptor_with_writable newLenDesc0 (Some false)
+                       else newLenDesc0) (fun newLenDesc1 ->
+                      if_bool
+                        (def s1 ("length")
+                          newLenDesc1 false) (fun s2 x ->
+                        out_error_or_cst s2 throw Coq_native_error_type
+                          (Coq_value_prim (Coq_prim_bool false)))))
+             else runs0.runs_type_object_define_own_prop_array_loop s1 c l
+                    newLen oldLen' newLenDesc newWritable throw def)))
+  else if not_decidable (bool_decidable newWritable)
+       then def s ("length")
+              { descriptor_value = None; descriptor_writable = (Some false);
+              descriptor_get = None; descriptor_set = None;
+              descriptor_enumerable = None; descriptor_configurable = None }
+              false
+       else res_ter s (res_val (Coq_value_prim (Coq_prim_bool true)))
+
+(** val object_define_own_prop :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name ->
+    descriptor -> strictness_flag -> result **)
+
+let object_define_own_prop runs0 s c l x desc throw =
+  let_binding (fun s0 throw0 ->
+    out_error_or_cst s0 throw0 Coq_native_error_type (Coq_value_prim
+      (Coq_prim_bool false))) (fun reject ->
+    let_binding (fun s0 x0 desc0 throw0 ->
+      if_spec (runs0.runs_type_object_get_own_prop s0 c l x0) (fun s1 d ->
+        if_some (run_object_method object_extensible_ s1 l) (fun ext ->
+          match d with
+          | Coq_full_descriptor_undef ->
+            if ext
+            then let_binding
+                   (if or_decidable (descriptor_is_generic_dec desc0)
+                         (descriptor_is_data_dec desc0)
+                    then Coq_attributes_data_of
+                           (attributes_data_of_descriptor desc0)
+                    else Coq_attributes_accessor_of
+                           (attributes_accessor_of_descriptor desc0))
+                   (fun a ->
+                   if_some
+                     (object_heap_map_properties_pickable_option s1 l
+                       (fun p -> Heap.write p x0 a)) (fun s2 ->
+                     res_ter s2
+                       (res_val (Coq_value_prim (Coq_prim_bool true)))))
+            else reject s1 throw0
+          | Coq_full_descriptor_some a ->
+            let_binding (fun s2 a0 ->
+              let a' = attributes_update a0 desc0 in
+              if_some
+                (object_heap_map_properties_pickable_option s2 l (fun p ->
+                  Heap.write p x0 a')) (fun s3 ->
+                res_ter s3 (res_val (Coq_value_prim (Coq_prim_bool true)))))
+              (fun object_define_own_prop_write ->
+              if descriptor_contains_dec (descriptor_of_attributes a) desc0
+              then res_ter s1 (res_val (Coq_value_prim (Coq_prim_bool true)))
+              else if attributes_change_enumerable_on_non_configurable_dec a
+                        desc0
+                   then reject s1 throw0
+                   else if descriptor_is_generic_dec desc0
+                        then object_define_own_prop_write s1 a
+                        else if not_decidable
+                                  (prop_eq_decidable
+                                    (attributes_is_data_dec a)
+                                    (descriptor_is_data_dec desc0))
+                             then if attributes_configurable a
+                                  then let_binding
+                                         (match a with
+                                          | Coq_attributes_data_of ad ->
+                                            Coq_attributes_accessor_of
+                                              (attributes_accessor_of_attributes_data
+                                                ad)
+                                          | Coq_attributes_accessor_of aa ->
+                                            Coq_attributes_data_of
+                                              (attributes_data_of_attributes_accessor
+                                                aa)) (fun a' ->
+                                         if_some
+                                           (object_heap_map_properties_pickable_option
+                                             s1 l (fun p ->
+                                             Heap.write p x0 a')) (fun s2 ->
+                                           object_define_own_prop_write s2 a'))
+                                  else reject s1 throw0
+                             else if and_decidable (attributes_is_data_dec a)
+                                       (descriptor_is_data_dec desc0)
+                                  then (match a with
+                                        | Coq_attributes_data_of ad ->
+                                          if attributes_change_data_on_non_configurable_dec
+                                               ad desc0
+                                          then reject s1 throw0
+                                          else object_define_own_prop_write
+                                                 s1 a
+                                        | Coq_attributes_accessor_of a0 ->
+                                          (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                                            s0
+                                            ("data is not accessor in [defineOwnProperty]"))
+                                  else if and_decidable
+                                            (not_decidable
+                                              (attributes_is_data_dec a))
+                                            (descriptor_is_accessor_dec
+                                              desc0)
+                                       then (match a with
+                                             | Coq_attributes_data_of a0 ->
+                                               (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                                                 s0
+                                                 ("accessor is not data in [defineOwnProperty]")
+                                             | Coq_attributes_accessor_of aa ->
+                                               if attributes_change_accessor_on_non_configurable_dec
+                                                    aa desc0
+                                               then reject s1 throw0
+                                               else object_define_own_prop_write
+                                                      s1 a)
+                                       else (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                                              s0
+                                              ("cases are mutually exclusives in [defineOwnProperty]")))))
+      (fun default ->
+      if_some (run_object_method object_define_own_prop_ s l) (fun b ->
+        match b with
+        | Coq_builtin_define_own_prop_default -> default s x desc throw
+        | Coq_builtin_define_own_prop_array ->
+          if_spec
+            (runs0.runs_type_object_get_own_prop s c l
+              ("length")) (fun s0 d ->
+            match d with
+            | Coq_full_descriptor_undef ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s0
+                ("Array length property descriptor cannot be undefined.")
+            | Coq_full_descriptor_some attr ->
+              (match attr with
+               | Coq_attributes_data_of a ->
+                 let_binding a.attributes_data_value (fun oldLen ->
+                   match oldLen with
+                   | Coq_value_prim w ->
+                     let_binding
+                       (JsNumber.to_uint32 (convert_prim_to_number w))
+                       (fun oldLen0 ->
+                       let_binding desc.descriptor_value (fun descValueOpt ->
+                         if string_comparable x
+                              ("length")
+                         then (match descValueOpt with
+                               | Some descValue ->
+                                 if_spec (to_uint32 runs0 s0 c descValue)
+                                   (fun s1 newLen ->
+                                   if_number (to_number runs0 s1 c descValue)
+                                     (fun s2 newLenN ->
+                                     if not_decidable
+                                          (number_comparable (of_int newLen)
+                                            newLenN)
+                                     then run_error s2 Coq_native_error_range
+                                     else let_binding
+                                            (descriptor_with_value desc (Some
+                                              (Coq_value_prim
+                                              (Coq_prim_number
+                                              (of_int newLen)))))
+                                            (fun newLenDesc ->
+                                            if le_int_decidable oldLen0
+                                                 newLen
+                                            then default s2
+                                                   ("length")
+                                                   newLenDesc throw
+                                            else if not_decidable
+                                                      (bool_decidable
+                                                        a.attributes_data_writable)
+                                                 then reject s2 throw
+                                                 else let_binding
+                                                        (match newLenDesc.descriptor_writable with
+                                                         | Some b0 ->
+                                                           if b0
+                                                           then true
+                                                           else false
+                                                         | None -> true)
+                                                        (fun newWritable ->
+                                                        let_binding
+                                                          (if not_decidable
+                                                                (bool_decidable
+                                                                  newWritable)
+                                                           then descriptor_with_writable
+                                                                  newLenDesc
+                                                                  (Some true)
+                                                           else newLenDesc)
+                                                          (fun newLenDesc0 ->
+                                                          if_bool
+                                                            (default s2
+                                                              ("length")
+                                                              newLenDesc0
+                                                              throw)
+                                                            (fun s3 succ ->
+                                                            if not_decidable
+                                                                 (bool_decidable
+                                                                   succ)
+                                                            then res_ter s3
+                                                                   (res_val
+                                                                    (Coq_value_prim
+                                                                    (Coq_prim_bool
+                                                                    false)))
+                                                            else run_object_define_own_prop_array_loop
+                                                                   runs0 s3 c
+                                                                   l newLen
+                                                                   oldLen0
+                                                                   newLenDesc0
+                                                                   newWritable
+                                                                   throw
+                                                                   default))))))
+                               | None ->
+                                 default s0
+                                   ("length")
+                                   desc throw)
+                         else if_spec
+                                (to_uint32 runs0 s0 c (Coq_value_prim
+                                  (Coq_prim_string x))) (fun s1 ilen ->
+                                if_string
+                                  (to_string runs0 s1 c (Coq_value_prim
+                                    (Coq_prim_number (of_int ilen))))
+                                  (fun s2 slen ->
+                                  if and_decidable (string_comparable x slen)
+                                       (not_decidable
+                                         (int_comparable ilen
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           ((fun p -> 1. +. (2. *. p))
+                                           1.)))))))))))))))))))))))))))))))))
+                                  then if_spec
+                                         (to_uint32 runs0 s2 c
+                                           (Coq_value_prim (Coq_prim_string
+                                           x))) (fun s3 index ->
+                                         if and_decidable
+                                              (le_int_decidable oldLen0
+                                                index)
+                                              (not_decidable
+                                                (bool_decidable
+                                                  a.attributes_data_writable))
+                                         then reject s3 throw
+                                         else if_bool
+                                                (default s3 x desc false)
+                                                (fun s4 b0 ->
+                                                if not_decidable
+                                                     (bool_decidable b0)
+                                                then reject s4 throw
+                                                else if le_int_decidable
+                                                          oldLen0 index
+                                                     then let a0 =
+                                                            descriptor_with_value
+                                                              (descriptor_of_attributes
+                                                                (Coq_attributes_data_of
+                                                                a)) (Some
+                                                              (Coq_value_prim
+                                                              (Coq_prim_number
+                                                              (of_int
+                                                                (Z.add index
+                                                                  1.)))))
+                                                          in
+                                                          default s4
+                                                            ("length")
+                                                            a0 false
+                                                     else res_ter s4
+                                                            (res_val
+                                                              (Coq_value_prim
+                                                              (Coq_prim_bool
+                                                              true)))))
+                                  else default s2 x desc throw))))
+                   | Coq_value_object l0 ->
+                     (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                       s0
+                       ("Spec asserts length of array is number."))
+               | Coq_attributes_accessor_of a ->
+                 (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                   s0
+                   ("Array length property descriptor cannot be accessor.")))
+        | Coq_builtin_define_own_prop_args_obj ->
+          if_some (run_object_method object_parameter_map_ s l) (fun lmapo ->
+            if_some lmapo (fun lmap ->
+              if_spec (runs0.runs_type_object_get_own_prop s c lmap x)
+                (fun s0 d ->
+                if_bool (default s0 x desc false) (fun s1 b0 ->
+                  if b0
+                  then let_binding (fun s2 ->
+                         res_ter s2
+                           (res_val (Coq_value_prim (Coq_prim_bool true))))
+                         (fun follow ->
+                         match d with
+                         | Coq_full_descriptor_undef -> follow s1
+                         | Coq_full_descriptor_some a ->
+                           if descriptor_is_accessor_dec desc
+                           then if_bool
+                                  (runs0.runs_type_object_delete s1 c lmap x
+                                    false) (fun s2 x0 -> follow s2)
+                           else let_binding (fun s2 ->
+                                  if option_comparable bool_comparable
+                                       desc.descriptor_writable (Some false)
+                                  then if_bool
+                                         (runs0.runs_type_object_delete s2 c
+                                           lmap x false) (fun s3 x0 ->
+                                         follow s3)
+                                  else follow s2) (fun follow0 ->
+                                  match desc.descriptor_value with
+                                  | Some v ->
+                                    if_void
+                                      (runs0.runs_type_object_put s1 c lmap x
+                                        v throw) (fun s2 -> follow0 s2)
+                                  | None -> follow0 s1))
+                  else reject s1 throw)))))))
+
+(** val run_to_descriptor :
+    runs_type -> state -> execution_ctx -> value -> descriptor specres **)
+
+let run_to_descriptor runs0 s c = function
+| Coq_value_prim p -> throw_result (run_error s Coq_native_error_type)
+| Coq_value_object l ->
+  let sub0 = fun s0 desc name conv k ->
+    if_bool (object_has_prop runs0 s0 c l name) (fun s1 has ->
+      if neg has
+      then k s1 desc
+      else if_value (run_object_get runs0 s1 c l name) (fun s2 v0 ->
+             if_spec (conv s2 v0 desc) k))
+  in
+  sub0 s descriptor_intro_empty
+    ("enumerable")
+    (fun s1 v1 desc ->
+    let b = convert_value_to_boolean v1 in
+    res_spec s1 (descriptor_with_enumerable desc (Some b))) (fun s1' desc ->
+    sub0 s1' desc
+      ("configurable")
+      (fun s2 v2 desc0 ->
+      let b = convert_value_to_boolean v2 in
+      res_spec s2 (descriptor_with_configurable desc0 (Some b)))
+      (fun s2' desc0 ->
+      sub0 s2' desc0 ("value")
+        (fun s3 v3 desc1 ->
+        res_spec s3 (descriptor_with_value desc1 (Some v3)))
+        (fun s3' desc1 ->
+        sub0 s3' desc1
+          ("writable")
+          (fun s4 v4 desc2 ->
+          let b = convert_value_to_boolean v4 in
+          res_spec s4 (descriptor_with_writable desc2 (Some b)))
+          (fun s4' desc2 ->
+          sub0 s4' desc2 ("get") (fun s5 v5 desc3 ->
+            if and_decidable
+                 (prop_eq_decidable (is_callable_dec s5 v5)
+                   (bool_decidable false))
+                 (not_decidable
+                   (value_comparable v5 (Coq_value_prim Coq_prim_undef)))
+            then throw_result (run_error s5 Coq_native_error_type)
+            else res_spec s5 (descriptor_with_get desc3 (Some v5)))
+            (fun s5' desc3 ->
+            sub0 s5' desc3 ("set") (fun s6 v6 desc4 ->
+              if and_decidable
+                   (prop_eq_decidable (is_callable_dec s6 v6)
+                     (bool_decidable false))
+                   (not_decidable
+                     (value_comparable v6 (Coq_value_prim Coq_prim_undef)))
+              then throw_result (run_error s6 Coq_native_error_type)
+              else res_spec s6 (descriptor_with_set desc4 (Some v6)))
+              (fun s7 desc4 ->
+              if and_decidable
+                   (or_decidable
+                     (not_decidable
+                       (option_comparable value_comparable
+                         desc4.descriptor_get None))
+                     (not_decidable
+                       (option_comparable value_comparable
+                         desc4.descriptor_set None)))
+                   (or_decidable
+                     (not_decidable
+                       (option_comparable value_comparable
+                         desc4.descriptor_value None))
+                     (not_decidable
+                       (option_comparable bool_comparable
+                         desc4.descriptor_writable None)))
+              then throw_result (run_error s7 Coq_native_error_type)
+              else res_spec s7 desc4))))))
+
+(** val prim_new_object : state -> prim -> result **)
+
+let prim_new_object s = function
+| Coq_prim_undef ->
+  (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+    s
+    ("[prim_new_object] received an null or undef.")
+| Coq_prim_null ->
+  (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+    s
+    ("[prim_new_object] received an null or undef.")
+| Coq_prim_bool b ->
+  result_out
+    (let_binding
+      (object_new (Coq_value_object (Coq_object_loc_prealloc
+        Coq_prealloc_bool_proto))
+        ("Boolean")) (fun o1 ->
+      let_binding
+        (object_with_primitive_value o1 (Coq_value_prim (Coq_prim_bool b)))
+        (fun o ->
+        let (l, s1) = object_alloc s o in
+        Coq_out_ter (s1, (res_val (Coq_value_object l))))))
+| Coq_prim_number n ->
+  result_out
+    (let_binding
+      (object_new (Coq_value_object (Coq_object_loc_prealloc
+        Coq_prealloc_number_proto))
+        ("Number")) (fun o1 ->
+      let_binding
+        (object_with_primitive_value o1 (Coq_value_prim (Coq_prim_number n)))
+        (fun o ->
+        let (l, s1) = object_alloc s o in
+        Coq_out_ter (s1, (res_val (Coq_value_object l))))))
+| Coq_prim_string s0 ->
+  let_binding
+    (object_new (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_string_proto))
+      ("String")) (fun o2 ->
+    let_binding
+      (object_with_get_own_property o2 Coq_builtin_get_own_prop_string)
+      (fun o1 ->
+      let_binding
+        (object_with_primitive_value o1 (Coq_value_prim (Coq_prim_string
+          s0))) (fun o ->
+        let (l, s1) = object_alloc s o in
+        if_some
+          (object_heap_map_properties_pickable_option s1 l (fun p ->
+            Heap.write p ("length")
+              (Coq_attributes_data_of
+              (attributes_data_intro_constant (Coq_value_prim
+                (Coq_prim_number (of_int (my_Z_of_nat (length s0)))))))))
+          (fun s' -> res_ter s' (res_val (Coq_value_object l))))))
+
+(** val to_object : state -> value -> result **)
+
+let to_object s = function
+| Coq_value_prim w ->
+  (match w with
+   | Coq_prim_undef -> run_error s Coq_native_error_type
+   | Coq_prim_null -> run_error s Coq_native_error_type
+   | Coq_prim_bool b -> prim_new_object s w
+   | Coq_prim_number n -> prim_new_object s w
+   | Coq_prim_string s0 -> prim_new_object s w)
+| Coq_value_object l ->
+  result_out (Coq_out_ter (s, (res_val (Coq_value_object l))))
+
+(** val run_object_prim_value : state -> object_loc -> result **)
+
+let run_object_prim_value s l =
+  if_some (run_object_method object_prim_value_ s l) (fun ov ->
+    if_some ov (fun v -> res_ter s (res_val v)))
+
+(** val prim_value_get :
+    runs_type -> state -> execution_ctx -> value -> prop_name -> result **)
+
+let prim_value_get runs0 s c v x =
+  if_object (to_object s v) (fun s' l ->
+    object_get_builtin runs0 s' c Coq_builtin_get_default v l x)
+
+(** val env_record_has_binding :
+    runs_type -> state -> execution_ctx -> env_loc -> prop_name -> result **)
+
+let env_record_has_binding runs0 s c l x =
+  if_some (env_record_binds_pickable_option s l) (fun e ->
+    match e with
+    | Coq_env_record_decl ed ->
+      result_out (Coq_out_ter (s,
+        (res_val (Coq_value_prim (Coq_prim_bool
+          (Heap.indom_decidable string_comparable ed x))))))
+    | Coq_env_record_object (l0, pt) -> object_has_prop runs0 s c l0 x)
+
+(** val lexical_env_get_identifier_ref :
+    runs_type -> state -> execution_ctx -> lexical_env -> prop_name ->
+    strictness_flag -> ref specres **)
+
+let rec lexical_env_get_identifier_ref runs0 s c x x0 str =
+  match x with
+  | [] ->
+    res_spec s (ref_create_value (Coq_value_prim Coq_prim_undef) x0 str)
+  | l :: x' ->
+    if_bool (env_record_has_binding runs0 s c l x0) (fun s1 has ->
+      if has
+      then res_spec s1 (ref_create_env_loc l x0 str)
+      else lexical_env_get_identifier_ref runs0 s1 c x' x0 str)
+
+(** val object_delete_default :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name ->
+    strictness_flag -> result **)
+
+let object_delete_default runs0 s c l x str =
+  if_spec (runs0.runs_type_object_get_own_prop s c l x) (fun s1 d ->
+    match d with
+    | Coq_full_descriptor_undef ->
+      res_ter s1 (res_val (Coq_value_prim (Coq_prim_bool true)))
+    | Coq_full_descriptor_some a ->
+      if attributes_configurable a
+      then if_some
+             (object_heap_map_properties_pickable_option s1 l (fun p ->
+               Heap.rem string_comparable p x)) (fun s' ->
+             res_ter s' (res_val (Coq_value_prim (Coq_prim_bool true))))
+      else out_error_or_cst s1 str Coq_native_error_type (Coq_value_prim
+             (Coq_prim_bool false)))
+
+(** val object_delete :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name ->
+    strictness_flag -> result **)
+
+let object_delete runs0 s c l x str =
+  if_some (run_object_method object_delete_ s l) (fun b ->
+    match b with
+    | Coq_builtin_delete_default -> object_delete_default runs0 s c l x str
+    | Coq_builtin_delete_args_obj ->
+      if_some (run_object_method object_parameter_map_ s l) (fun mo ->
+        if_some mo (fun m ->
+          if_spec (runs0.runs_type_object_get_own_prop s c m x) (fun s1 d ->
+            if_bool (object_delete_default runs0 s1 c l x str) (fun s2 b0 ->
+              if b0
+              then (match d with
+                    | Coq_full_descriptor_undef ->
+                      res_ter s2
+                        (res_val (Coq_value_prim (Coq_prim_bool b0)))
+                    | Coq_full_descriptor_some a ->
+                      if_bool (runs0.runs_type_object_delete s2 c m x false)
+                        (fun s3 b' ->
+                        res_ter s3
+                          (res_val (Coq_value_prim (Coq_prim_bool b0)))))
+              else res_ter s2 (res_val (Coq_value_prim (Coq_prim_bool b0))))))))
+
+(** val env_record_delete_binding :
+    runs_type -> state -> execution_ctx -> env_loc -> prop_name -> result **)
+
+let env_record_delete_binding runs0 s c l x =
+  if_some (env_record_binds_pickable_option s l) (fun e ->
+    match e with
+    | Coq_env_record_decl ed ->
+      (match Heap.read_option string_comparable ed x with
+       | Some p ->
+         let (mu, v) = p in
+         (match mu with
+          | Coq_mutability_uninitialized_immutable ->
+            result_out (Coq_out_ter (s,
+              (res_val (Coq_value_prim (Coq_prim_bool false)))))
+          | Coq_mutability_immutable ->
+            result_out (Coq_out_ter (s,
+              (res_val (Coq_value_prim (Coq_prim_bool false)))))
+          | Coq_mutability_nondeletable ->
+            result_out (Coq_out_ter (s,
+              (res_val (Coq_value_prim (Coq_prim_bool false)))))
+          | Coq_mutability_deletable ->
+            let s' =
+              env_record_write s l (Coq_env_record_decl
+                (decl_env_record_rem ed x))
+            in
+            result_out (Coq_out_ter (s',
+              (res_val (Coq_value_prim (Coq_prim_bool true))))))
+       | None ->
+         result_out (Coq_out_ter (s,
+           (res_val (Coq_value_prim (Coq_prim_bool true))))))
+    | Coq_env_record_object (l0, pt) ->
+      runs0.runs_type_object_delete s c l0 x throw_false)
+
+(** val env_record_implicit_this_value : state -> env_loc -> value option **)
+
+let env_record_implicit_this_value s l =
+  if_some_or_default (env_record_binds_pickable_option s l) None (fun e ->
+    Some
+    (match e with
+     | Coq_env_record_decl ed -> Coq_value_prim Coq_prim_undef
+     | Coq_env_record_object (l0, provide_this) ->
+       if provide_this
+       then Coq_value_object l0
+       else Coq_value_prim Coq_prim_undef))
+
+(** val identifier_resolution :
+    runs_type -> state -> execution_ctx -> prop_name -> ref specres **)
+
+let identifier_resolution runs0 s c x =
+  let x0 = c.execution_ctx_lexical_env in
+  let str = c.execution_ctx_strict in
+  lexical_env_get_identifier_ref runs0 s c x0 x str
+
+(** val env_record_get_binding_value :
+    runs_type -> state -> execution_ctx -> env_loc -> prop_name ->
+    strictness_flag -> result **)
+
+let env_record_get_binding_value runs0 s c l x str =
+  if_some (env_record_binds_pickable_option s l) (fun e ->
+    match e with
+    | Coq_env_record_decl ed ->
+      if_some (Heap.read_option string_comparable ed x) (fun rm ->
+        let (mu, v) = rm in
+        if mutability_comparable mu Coq_mutability_uninitialized_immutable
+        then out_error_or_cst s str Coq_native_error_ref (Coq_value_prim
+               Coq_prim_undef)
+        else res_ter s (res_val v))
+    | Coq_env_record_object (l0, pt) ->
+      if_bool (object_has_prop runs0 s c l0 x) (fun s1 has ->
+        if has
+        then run_object_get runs0 s1 c l0 x
+        else out_error_or_cst s1 str Coq_native_error_ref (Coq_value_prim
+               Coq_prim_undef)))
+
+(** val ref_get_value :
+    runs_type -> state -> execution_ctx -> resvalue -> value specres **)
+
+let ref_get_value runs0 s c = function
+| Coq_resvalue_empty ->
+  (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+    s
+    ("[ref_get_value] received an empty result.")
+| Coq_resvalue_value v -> res_spec s v
+| Coq_resvalue_ref r ->
+  let_binding (fun tt ->
+    match r.ref_base with
+    | Coq_ref_base_type_value v ->
+      if ref_kind_comparable (ref_kind_of r) Coq_ref_kind_primitive_base
+      then if_value (prim_value_get runs0 s c v r.ref_name) res_spec
+      else (match v with
+            | Coq_value_prim p ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s
+                ("[ref_get_value] received a primitive value whose kind is not primitive.")
+            | Coq_value_object l ->
+              if_value (run_object_get runs0 s c l r.ref_name) res_spec)
+    | Coq_ref_base_type_env_loc l ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[ref_get_value] received a reference to a value whose base type is an environnment record."))
+    (fun for_base_or_object ->
+    match ref_kind_of r with
+    | Coq_ref_kind_null ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[ref_get_value] received a reference whose base is [null].")
+    | Coq_ref_kind_undef -> throw_result (run_error s Coq_native_error_ref)
+    | Coq_ref_kind_primitive_base -> for_base_or_object ()
+    | Coq_ref_kind_object -> for_base_or_object ()
+    | Coq_ref_kind_env_record ->
+      (match r.ref_base with
+       | Coq_ref_base_type_value v ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[ref_get_value] received a reference to an environnment record whose base type is a value.")
+       | Coq_ref_base_type_env_loc l ->
+         if_value
+           (env_record_get_binding_value runs0 s c l r.ref_name r.ref_strict)
+           res_spec))
+
+let ref_get_value runs s c r =
+   let res = ref_get_value runs s c r in match res with
+     | JsInterpreterMonads.Coq_result_some (Coq_specret_val (_, rs)) -> begin match rs with
+         | Coq_value_prim (Coq_prim_undef) ->
+           prerr_string ("Warning: ref_get_value returns the undefined value on "); prerr_string (Prheap.prresvalue r); prerr_newline(); res
+         | _ -> res
+       end
+     | _ -> res
+ 
+ (** val run_expr_get_value :
+    runs_type -> state -> execution_ctx -> expr -> value specres **)
+
+let run_expr_get_value runs0 s c e =
+  if_success (runs0.runs_type_expr s c e) (fun s0 rv ->
+    ref_get_value runs0 s0 c rv)
+
+(** val object_put_complete :
+    runs_type -> builtin_put -> state -> execution_ctx -> value -> object_loc
+    -> prop_name -> value -> strictness_flag -> result_void **)
+
+let object_put_complete runs0 b s c vthis l x v str =
+  let Coq_builtin_put_default = b in
+  if_bool (object_can_put runs0 s c l x) (fun s1 b0 ->
+    if b0
+    then if_spec (runs0.runs_type_object_get_own_prop s1 c l x) (fun s2 d ->
+           let_binding (fun x0 ->
+             if_spec (run_object_get_prop runs0 s2 c l x) (fun s3 d' ->
+               let_binding (fun x1 ->
+                 match vthis with
+                 | Coq_value_prim wthis ->
+                   out_error_or_void s3 str Coq_native_error_type
+                 | Coq_value_object lthis ->
+                   let_binding (descriptor_intro_data v true true true)
+                     (fun desc ->
+                     if_success
+                       (object_define_own_prop runs0 s3 c l x desc str)
+                       (fun s4 rv -> res_void s4))) (fun follow' ->
+                 match d' with
+                 | Coq_full_descriptor_undef -> follow' ()
+                 | Coq_full_descriptor_some a ->
+                   (match a with
+                    | Coq_attributes_data_of a0 -> follow' ()
+                    | Coq_attributes_accessor_of aa' ->
+                      (match aa'.attributes_accessor_set with
+                       | Coq_value_prim p ->
+                         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                           s3
+                           ("[object_put_complete] found a primitive in an `set\' accessor.")
+                       | Coq_value_object lfsetter ->
+                         if_success
+                           (runs0.runs_type_call s3 c lfsetter vthis
+                             (v :: [])) (fun s4 rv -> res_void s4))))))
+             (fun follow ->
+             match d with
+             | Coq_full_descriptor_undef -> follow ()
+             | Coq_full_descriptor_some a ->
+               (match a with
+                | Coq_attributes_data_of ad ->
+                  (match vthis with
+                   | Coq_value_prim wthis ->
+                     out_error_or_void s2 str Coq_native_error_type
+                   | Coq_value_object lthis ->
+                     let_binding { descriptor_value = (Some v);
+                       descriptor_writable = None; descriptor_get = None;
+                       descriptor_set = None; descriptor_enumerable = None;
+                       descriptor_configurable = None } (fun desc ->
+                       if_success
+                         (object_define_own_prop runs0 s2 c l x desc str)
+                         (fun s3 rv -> res_void s3)))
+                | Coq_attributes_accessor_of a0 -> follow ())))
+    else out_error_or_void s1 str Coq_native_error_type)
+
+(** val object_put :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name -> value
+    -> strictness_flag -> result_void **)
+
+let object_put runs0 s c l x v str =
+  if_some (run_object_method object_put_ s l) (fun b ->
+    object_put_complete runs0 b s c (Coq_value_object l) l x v str)
+
+(** val env_record_set_mutable_binding :
+    runs_type -> state -> execution_ctx -> env_loc -> prop_name -> value ->
+    strictness_flag -> result_void **)
+
+let env_record_set_mutable_binding runs0 s c l x v str =
+  if_some (env_record_binds_pickable_option s l) (fun e ->
+    match e with
+    | Coq_env_record_decl ed ->
+      if_some (Heap.read_option string_comparable ed x) (fun rm ->
+        let (mu, v_old) = rm in
+        if not_decidable (mutability_comparable mu Coq_mutability_immutable)
+        then res_void (env_record_write_decl_env s l x mu v)
+        else out_error_or_void s str Coq_native_error_type)
+    | Coq_env_record_object (l0, pt) -> object_put runs0 s c l0 x v str)
+
+(** val prim_value_put :
+    runs_type -> state -> execution_ctx -> prim -> prop_name -> value ->
+    strictness_flag -> result_void **)
+
+let prim_value_put runs0 s c w x v str =
+  if_object (to_object s (Coq_value_prim w)) (fun s1 l ->
+    object_put_complete runs0 Coq_builtin_put_default s1 c (Coq_value_prim w)
+      l x v str)
+
+(** val ref_put_value :
+    runs_type -> state -> execution_ctx -> resvalue -> value -> result_void **)
+
+let ref_put_value runs0 s c rv v =
+  match rv with
+  | Coq_resvalue_empty ->
+    (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+      s
+      ("[ref_put_value] received an empty result.")
+  | Coq_resvalue_value v0 -> run_error s Coq_native_error_ref
+  | Coq_resvalue_ref r ->
+    if ref_kind_comparable (ref_kind_of r) Coq_ref_kind_undef
+    then if r.ref_strict
+         then run_error s Coq_native_error_ref
+         else object_put runs0 s c (Coq_object_loc_prealloc
+                Coq_prealloc_global) r.ref_name v throw_false
+    else if or_decidable
+              (ref_kind_comparable (ref_kind_of r)
+                Coq_ref_kind_primitive_base)
+              (or_decidable
+                (ref_kind_comparable (ref_kind_of r) Coq_ref_kind_null)
+                (ref_kind_comparable (ref_kind_of r) Coq_ref_kind_object))
+         then (match r.ref_base with
+               | Coq_ref_base_type_value v' ->
+                 if ref_kind_comparable (ref_kind_of r)
+                      Coq_ref_kind_primitive_base
+                 then (match v' with
+                       | Coq_value_prim w ->
+                         prim_value_put runs0 s c w r.ref_name v r.ref_strict
+                       | Coq_value_object o ->
+                         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                           s
+                           ("[ref_put_value] impossible case"))
+                 else (match v' with
+                       | Coq_value_prim p ->
+                         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                           s
+                           ("[ref_put_value] impossible case")
+                       | Coq_value_object l ->
+                         object_put runs0 s c l r.ref_name v r.ref_strict)
+               | Coq_ref_base_type_env_loc l ->
+                 (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                   s
+                   ("[ref_put_value] contradicts ref_is_property"))
+         else (match r.ref_base with
+               | Coq_ref_base_type_value v0 ->
+                 (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                   s
+                   ("[ref_put_value] impossible spec")
+               | Coq_ref_base_type_env_loc l ->
+                 env_record_set_mutable_binding runs0 s c l r.ref_name v
+                   r.ref_strict)
+
+(** val env_record_create_mutable_binding :
+    runs_type -> state -> execution_ctx -> env_loc -> prop_name -> bool
+    option -> result_void **)
+
+let env_record_create_mutable_binding runs0 s c l x deletable_opt =
+  let_binding (unsome_default false deletable_opt) (fun deletable ->
+    if_some (env_record_binds_pickable_option s l) (fun e ->
+      match e with
+      | Coq_env_record_decl ed ->
+        if Heap.indom_decidable string_comparable ed x
+        then (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+               s
+               ("Already declared environnment record in [env_record_create_mutable_binding].")
+        else let_binding
+               (env_record_write_decl_env s l x
+                 (mutability_of_bool deletable) (Coq_value_prim
+                 Coq_prim_undef)) (fun s' -> res_void s')
+      | Coq_env_record_object (l0, pt) ->
+        if_bool (object_has_prop runs0 s c l0 x) (fun s1 has ->
+          if has
+          then (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                 s1
+                 ("Already declared binding in [env_record_create_mutable_binding].")
+          else let_binding { attributes_data_value = (Coq_value_prim
+                 Coq_prim_undef); attributes_data_writable = true;
+                 attributes_data_enumerable = true;
+                 attributes_data_configurable = deletable } (fun a ->
+                 if_success
+                   (object_define_own_prop runs0 s1 c l0 x
+                     (descriptor_of_attributes (Coq_attributes_data_of a))
+                     throw_true) (fun s2 rv -> res_void s2)))))
+
+(** val env_record_create_set_mutable_binding :
+    runs_type -> state -> execution_ctx -> env_loc -> prop_name -> bool
+    option -> value -> strictness_flag -> result_void **)
+
+let env_record_create_set_mutable_binding runs0 s c l x deletable_opt v str =
+  if_void (env_record_create_mutable_binding runs0 s c l x deletable_opt)
+    (fun s0 -> env_record_set_mutable_binding runs0 s0 c l x v str)
+
+(** val env_record_create_immutable_binding :
+    state -> env_loc -> prop_name -> result_void **)
+
+let env_record_create_immutable_binding s l x =
+  if_some (env_record_binds_pickable_option s l) (fun e ->
+    match e with
+    | Coq_env_record_decl ed ->
+      if Heap.indom_decidable string_comparable ed x
+      then (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+             s
+             ("Already declared environnment record in [env_record_create_immutable_binding].")
+      else res_void
+             (env_record_write_decl_env s l x
+               Coq_mutability_uninitialized_immutable (Coq_value_prim
+               Coq_prim_undef))
+    | Coq_env_record_object (o, p) ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[env_record_create_immutable_binding] received an environnment record object."))
+
+(** val env_record_initialize_immutable_binding :
+    state -> env_loc -> prop_name -> value -> result_void **)
+
+let env_record_initialize_immutable_binding s l x v =
+  if_some (env_record_binds_pickable_option s l) (fun e ->
+    match e with
+    | Coq_env_record_decl ed ->
+      if_some (decl_env_record_pickable_option ed x) (fun evs ->
+        if prod_comparable mutability_comparable value_comparable evs
+             (Coq_mutability_uninitialized_immutable, (Coq_value_prim
+             Coq_prim_undef))
+        then let_binding
+               (env_record_write_decl_env s l x Coq_mutability_immutable v)
+               (fun s' -> res_void s')
+        else (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+               s
+               ("Non suitable binding in [env_record_initialize_immutable_binding]."))
+    | Coq_env_record_object (o, p) ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[env_record_initialize_immutable_binding] received an environnment record object."))
+
+(** val call_object_new : state -> value -> result **)
+
+let call_object_new s v =
+  match type_of v with
+  | Coq_type_undef ->
+    result_out
+      (let_binding
+        (object_new (Coq_value_object (Coq_object_loc_prealloc
+          Coq_prealloc_object_proto))
+          ("Object")) (fun o ->
+        let_binding (object_alloc s o) (fun p ->
+          let (l, s') = p in Coq_out_ter (s', (res_val (Coq_value_object l))))))
+  | Coq_type_null ->
+    result_out
+      (let_binding
+        (object_new (Coq_value_object (Coq_object_loc_prealloc
+          Coq_prealloc_object_proto))
+          ("Object")) (fun o ->
+        let_binding (object_alloc s o) (fun p ->
+          let (l, s') = p in Coq_out_ter (s', (res_val (Coq_value_object l))))))
+  | Coq_type_bool -> to_object s v
+  | Coq_type_number -> to_object s v
+  | Coq_type_string -> to_object s v
+  | Coq_type_object -> result_out (Coq_out_ter (s, (res_val v)))
+
+(** val array_args_map_loop :
+    runs_type -> state -> execution_ctx -> object_loc -> value list -> float
+    -> result_void **)
+
+let rec array_args_map_loop runs0 s c l args ind =
+  match args with
+  | [] -> res_void s
+  | h :: rest ->
+    if_some
+      (object_heap_map_properties_pickable_option s l (fun p ->
+        Heap.write p (JsNumber.to_string (of_int ind))
+          (Coq_attributes_data_of (attributes_data_intro_all_true h))))
+      (fun s' -> array_args_map_loop runs0 s' c l rest (Z.add ind 1.))
+
+(** val string_of_prealloc : prealloc -> char list **)
+
+let string_of_prealloc = function
+| Coq_prealloc_global -> "global"
+| Coq_prealloc_global_eval ->
+  "global_eval"
+| Coq_prealloc_global_parse_int ->
+  "global_parse_int"
+| Coq_prealloc_global_parse_float ->
+  "global_parse_float"
+| Coq_prealloc_global_is_finite ->
+  "global_is_finite"
+| Coq_prealloc_global_is_nan ->
+  "global_is_nan"
+| Coq_prealloc_global_decode_uri ->
+  "global_decode_uri"
+| Coq_prealloc_global_decode_uri_component ->
+  "global_decode_uri_component"
+| Coq_prealloc_global_encode_uri ->
+  "global_encode_uri"
+| Coq_prealloc_global_encode_uri_component ->
+  "global_encode_uri_component"
+| Coq_prealloc_object -> "object"
+| Coq_prealloc_object_get_proto_of ->
+  "object_get_proto_of"
+| Coq_prealloc_object_get_own_prop_descriptor ->
+  "object_get_own_prop_descriptor"
+| Coq_prealloc_object_get_own_prop_name ->
+  "object_get_own_prop_name"
+| Coq_prealloc_object_create ->
+  "object_create"
+| Coq_prealloc_object_define_prop ->
+  "object_define_prop"
+| Coq_prealloc_object_define_props ->
+  "object_define_props"
+| Coq_prealloc_object_seal ->
+  "object_seal"
+| Coq_prealloc_object_freeze ->
+  "object_freeze"
+| Coq_prealloc_object_prevent_extensions ->
+  "object_prevent_extensions"
+| Coq_prealloc_object_is_sealed ->
+  "object_is_sealed"
+| Coq_prealloc_object_is_frozen ->
+  "object_is_frozen"
+| Coq_prealloc_object_is_extensible ->
+  "object_is_extensible"
+| Coq_prealloc_object_keys ->
+  "object_keys"
+| Coq_prealloc_object_keys_call ->
+  "object_keys_call"
+| Coq_prealloc_object_proto ->
+  "object_proto_"
+| Coq_prealloc_object_proto_to_string ->
+  "object_proto_to_string"
+| Coq_prealloc_object_proto_value_of ->
+  "object_proto_value_of"
+| Coq_prealloc_object_proto_has_own_prop ->
+  "object_proto_has_own_prop"
+| Coq_prealloc_object_proto_is_prototype_of ->
+  "object_proto_is_prototype_of"
+| Coq_prealloc_object_proto_prop_is_enumerable ->
+  "object_proto_prop_is_enumerable"
+| Coq_prealloc_function ->
+  "function"
+| Coq_prealloc_function_proto ->
+  "function_proto"
+| Coq_prealloc_function_proto_to_string ->
+  "function_proto_to_string"
+| Coq_prealloc_function_proto_apply ->
+  "function_proto_apply"
+| Coq_prealloc_function_proto_call ->
+  "function_proto_call"
+| Coq_prealloc_function_proto_bind ->
+  "function_proto_bind"
+| Coq_prealloc_bool -> "bool"
+| Coq_prealloc_bool_proto ->
+  "bool_proto"
+| Coq_prealloc_bool_proto_to_string ->
+  "bool_proto_to_string"
+| Coq_prealloc_bool_proto_value_of ->
+  "bool_proto_value_of"
+| Coq_prealloc_number -> "number"
+| Coq_prealloc_number_proto ->
+  "number_proto"
+| Coq_prealloc_number_proto_to_string ->
+  "number_proto_to_string"
+| Coq_prealloc_number_proto_value_of ->
+  "number_proto_value_of"
+| Coq_prealloc_number_proto_to_fixed ->
+  "number_proto_to_fixed"
+| Coq_prealloc_number_proto_to_exponential ->
+  "number_proto_to_exponential"
+| Coq_prealloc_number_proto_to_precision ->
+  "number_proto_to_precision"
+| Coq_prealloc_array -> "array"
+| Coq_prealloc_array_is_array ->
+  "array_is_array"
+| Coq_prealloc_array_proto ->
+  "array_proto"
+| Coq_prealloc_array_proto_to_string ->
+  "array_proto_to_string"
+| Coq_prealloc_array_proto_join ->
+  "array_proto_join"
+| Coq_prealloc_array_proto_pop ->
+  "array_proto_pop"
+| Coq_prealloc_array_proto_push ->
+  "array_proto_push"
+| Coq_prealloc_string -> "string"
+| Coq_prealloc_string_proto ->
+  "string_proto"
+| Coq_prealloc_string_proto_to_string ->
+  "string_proto_to_string"
+| Coq_prealloc_string_proto_value_of ->
+  "string_proto_value_of"
+| Coq_prealloc_string_proto_char_at ->
+  "string_proto_char_at"
+| Coq_prealloc_string_proto_char_code_at ->
+  "string_proto_char_code_at"
+| Coq_prealloc_math -> "math"
+| Coq_prealloc_mathop m -> "mathop"
+| Coq_prealloc_date -> "date"
+| Coq_prealloc_regexp -> "regexp"
+| Coq_prealloc_error -> "error"
+| Coq_prealloc_error_proto ->
+  "error_proto"
+| Coq_prealloc_native_error n ->
+  "native_error"
+| Coq_prealloc_native_error_proto n ->
+  "native_error_proto"
+| Coq_prealloc_error_proto_to_string ->
+  "error_proto_to_string"
+| Coq_prealloc_throw_type_error ->
+  "throw_type_error"
+| Coq_prealloc_json -> "json"
+
+(** val run_construct_prealloc :
+    runs_type -> state -> execution_ctx -> prealloc -> value list -> result **)
+
+let run_construct_prealloc runs0 s c b args =
+  match b with
+  | Coq_prealloc_global ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_global_eval ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_global_parse_int ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_global_parse_float ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_global_is_finite ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_global_is_nan ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_global_decode_uri ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_global_decode_uri_component ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_global_encode_uri ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_global_encode_uri_component ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object ->
+    let_binding (get_arg 0 args) (fun v -> call_object_new s v)
+  | Coq_prealloc_object_get_proto_of ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_get_own_prop_descriptor ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_get_own_prop_name ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_create ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_define_prop ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_define_props ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_seal ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_freeze ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_prevent_extensions ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_is_sealed ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_is_frozen ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_is_extensible ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_keys ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_keys_call ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_proto_to_string ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_proto_value_of ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_proto_has_own_prop ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_proto_is_prototype_of ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_object_proto_prop_is_enumerable ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_function ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_function_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_function_proto_to_string ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_function_proto_apply ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_function_proto_call ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_function_proto_bind ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_bool ->
+    result_out
+      (let_binding (get_arg 0 args) (fun v ->
+        let_binding (convert_value_to_boolean v) (fun b0 ->
+          let_binding
+            (object_new (Coq_value_object (Coq_object_loc_prealloc
+              Coq_prealloc_bool_proto))
+              ("Boolean")) (fun o1 ->
+            let_binding
+              (object_with_primitive_value o1 (Coq_value_prim (Coq_prim_bool
+                b0))) (fun o ->
+              let_binding (object_alloc s o) (fun p ->
+                let (l, s') = p in
+                Coq_out_ter (s', (res_val (Coq_value_object l)))))))))
+  | Coq_prealloc_bool_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_bool_proto_to_string ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_bool_proto_value_of ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_number ->
+    let_binding (fun s' v ->
+      let_binding
+        (object_new (Coq_value_object (Coq_object_loc_prealloc
+          Coq_prealloc_number_proto))
+          ("Number")) (fun o1 ->
+        let_binding (object_with_primitive_value o1 v) (fun o ->
+          let (l, s1) = object_alloc s' o in
+          result_out (Coq_out_ter (s1, (res_val (Coq_value_object l)))))))
+      (fun follow ->
+      if list_eq_nil_decidable args
+      then follow s (Coq_value_prim (Coq_prim_number zero))
+      else let_binding (get_arg 0 args) (fun v ->
+             if_number (to_number runs0 s c v) (fun x x0 ->
+               follow x (Coq_value_prim (Coq_prim_number x0)))))
+  | Coq_prealloc_number_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_number_proto_to_string ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_number_proto_value_of ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_number_proto_to_fixed ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_number_proto_to_exponential ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_number_proto_to_precision ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_array ->
+    let_binding
+      (object_new (Coq_value_object (Coq_object_loc_prealloc
+        Coq_prealloc_array_proto)) ("Array"))
+      (fun o' ->
+      let_binding (object_for_array o' Coq_builtin_define_own_prop_array)
+        (fun o ->
+        let_binding (object_alloc s o) (fun p ->
+          let (l, s') = p in
+          let_binding (fun s'' length0 ->
+            if_some
+              (object_heap_map_properties_pickable_option s'' l (fun p0 ->
+                Heap.write p0 ("length")
+                  (Coq_attributes_data_of { attributes_data_value =
+                  (Coq_value_prim (Coq_prim_number (of_int length0)));
+                  attributes_data_writable = true;
+                  attributes_data_enumerable = false;
+                  attributes_data_configurable = false }))) (fun s0 ->
+              res_ter s0 (res_val (Coq_value_object l)))) (fun follow ->
+            let_binding (LibList.length args) (fun arg_len ->
+              if nat_comparable arg_len (Pervasives.succ 0)
+              then let_binding (get_arg 0 args) (fun v ->
+                     match v with
+                     | Coq_value_prim p0 ->
+                       (match p0 with
+                        | Coq_prim_undef ->
+                          if_some
+                            (object_heap_map_properties_pickable_option s' l
+                              (fun p1 ->
+                              Heap.write p1 ("0") (Coq_attributes_data_of
+                                (attributes_data_intro_all_true v))))
+                            (fun s0 ->
+                            follow s0 (my_Z_of_nat (Pervasives.succ 0)))
+                        | Coq_prim_null ->
+                          if_some
+                            (object_heap_map_properties_pickable_option s' l
+                              (fun p1 ->
+                              Heap.write p1 ("0") (Coq_attributes_data_of
+                                (attributes_data_intro_all_true v))))
+                            (fun s0 ->
+                            follow s0 (my_Z_of_nat (Pervasives.succ 0)))
+                        | Coq_prim_bool b0 ->
+                          if_some
+                            (object_heap_map_properties_pickable_option s' l
+                              (fun p1 ->
+                              Heap.write p1 ("0") (Coq_attributes_data_of
+                                (attributes_data_intro_all_true v))))
+                            (fun s0 ->
+                            follow s0 (my_Z_of_nat (Pervasives.succ 0)))
+                        | Coq_prim_number vlen ->
+                          if_spec
+                            (to_uint32 runs0 s' c (Coq_value_prim
+                              (Coq_prim_number vlen))) (fun s0 ilen ->
+                            if number_comparable (of_int ilen) vlen
+                            then follow s0 ilen
+                            else run_error s0 Coq_native_error_range)
+                        | Coq_prim_string s0 ->
+                          if_some
+                            (object_heap_map_properties_pickable_option s' l
+                              (fun p1 ->
+                              Heap.write p1 ("0") (Coq_attributes_data_of
+                                (attributes_data_intro_all_true v))))
+                            (fun s1 ->
+                            follow s1 (my_Z_of_nat (Pervasives.succ 0))))
+                     | Coq_value_object o0 ->
+                       if_some
+                         (object_heap_map_properties_pickable_option s' l
+                           (fun p0 ->
+                           Heap.write p0 ("0") (Coq_attributes_data_of
+                             (attributes_data_intro_all_true v)))) (fun s0 ->
+                         follow s0 (my_Z_of_nat (Pervasives.succ 0))))
+              else if_some
+                     (object_heap_map_properties_pickable_option s' l
+                       (fun p0 ->
+                       Heap.write p0
+                         ("length")
+                         (Coq_attributes_data_of { attributes_data_value =
+                         (Coq_value_prim (Coq_prim_number
+                         (of_int (my_Z_of_nat arg_len))));
+                         attributes_data_writable = true;
+                         attributes_data_enumerable = false;
+                         attributes_data_configurable = false }))) (fun s0 ->
+                     if_void (array_args_map_loop runs0 s0 c l args 0.)
+                       (fun s1 -> res_ter s1 (res_val (Coq_value_object l)))))))))
+  | Coq_prealloc_array_is_array ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_array_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_array_proto_to_string ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_array_proto_join ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_array_proto_pop ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_array_proto_push ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_string ->
+    let_binding
+      (object_new (Coq_value_object (Coq_object_loc_prealloc
+        Coq_prealloc_string_proto))
+        ("String")) (fun o2 ->
+      let_binding
+        (object_with_get_own_property o2 Coq_builtin_get_own_prop_string)
+        (fun o1 ->
+        let_binding (fun s0 s1 ->
+          let_binding
+            (object_with_primitive_value o1 (Coq_value_prim (Coq_prim_string
+              s1))) (fun o ->
+            let (l, s2) = object_alloc s0 o in
+            let_binding
+              (attributes_data_intro_constant (Coq_value_prim
+                (Coq_prim_number (of_int (my_Z_of_nat (length s1))))))
+              (fun lenDesc ->
+              if_some
+                (object_heap_map_properties_pickable_option s2 l (fun p ->
+                  Heap.write p ("length")
+                    (Coq_attributes_data_of lenDesc))) (fun s' ->
+                res_ter s' (res_val (Coq_value_object l)))))) (fun follow ->
+          let_binding (LibList.length args) (fun arg_len ->
+            if nat_comparable arg_len 0
+            then follow s []
+            else let_binding (get_arg 0 args) (fun arg ->
+                   if_string (to_string runs0 s c arg) (fun s0 s1 ->
+                     follow s0 s1))))))
+  | Coq_prealloc_string_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_string_proto_to_string ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_string_proto_value_of ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_string_proto_char_at ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_string_proto_char_code_at ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_math ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_mathop m ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_date ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_regexp ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_error ->
+    let_binding (get_arg 0 args) (fun v ->
+      build_error s (Coq_value_object (Coq_object_loc_prealloc
+        Coq_prealloc_error_proto)) v)
+  | Coq_prealloc_error_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_native_error ne ->
+    let_binding (get_arg 0 args) (fun v ->
+      build_error s (Coq_value_object (Coq_object_loc_prealloc
+        (Coq_prealloc_native_error_proto ne))) v)
+  | Coq_prealloc_native_error_proto n ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_error_proto_to_string ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_throw_type_error ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+  | Coq_prealloc_json ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Construct prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented.")))
+
+(** val run_construct_default :
+    runs_type -> state -> execution_ctx -> object_loc -> value list -> __
+    specres **)
+
+let run_construct_default runs0 s c l args =
+  if_value
+    (run_object_get runs0 s c l
+      ("prototype"))
+    (fun s1 v1 ->
+    let_binding
+      (if type_comparable (type_of v1) Coq_type_object
+       then v1
+       else Coq_value_object (Coq_object_loc_prealloc
+              Coq_prealloc_object_proto)) (fun vproto ->
+      let_binding
+        (object_new vproto ("Object"))
+        (fun o ->
+        let_binding (object_alloc s1 o) (fun p ->
+          let (l', s2) = p in
+          if_value (runs0.runs_type_call s2 c l (Coq_value_object l') args)
+            (fun s3 v2 ->
+            let_binding
+              (if type_comparable (type_of v2) Coq_type_object
+               then v2
+               else Coq_value_object l') (fun vr -> res_ter s3 (res_val vr)))))))
+
+(** val run_construct :
+    runs_type -> state -> execution_ctx -> construct -> object_loc -> value
+    list -> result **)
+
+let run_construct runs0 s c co l args =
+  match co with
+  | Coq_construct_default -> run_construct_default runs0 s c l args
+  | Coq_construct_after_bind ->
+    if_some (run_object_method object_target_function_ s l) (fun otrg ->
+      if_some otrg (fun target ->
+        if_some (run_object_method object_construct_ s target) (fun oco ->
+          match oco with
+          | Some co0 ->
+            if_some (run_object_method object_bound_args_ s l) (fun oarg ->
+              if_some oarg (fun boundArgs ->
+                let_binding (LibList.append boundArgs args) (fun arguments ->
+                  runs0.runs_type_construct s c co0 target arguments)))
+          | None -> run_error s Coq_native_error_type)))
+  | Coq_construct_prealloc b -> run_construct_prealloc runs0 s c b args
+
+(** val run_call_default :
+    runs_type -> state -> execution_ctx -> object_loc -> result **)
+
+let run_call_default runs0 s c lf =
+  let_binding
+    (result_out (Coq_out_ter (s, (res_val (Coq_value_prim Coq_prim_undef)))))
+    (fun default ->
+    if_some (run_object_method object_code_ s lf) (fun oC ->
+      match oC with
+      | Some bd ->
+        if list_eq_nil_decidable (prog_elements (funcbody_prog bd))
+        then default
+        else if_success_or_return
+               (runs0.runs_type_prog s c (funcbody_prog bd)) (fun s' ->
+               result_out (Coq_out_ter (s',
+                 (res_val (Coq_value_prim Coq_prim_undef))))) (fun s' rv ->
+               result_out (Coq_out_ter (s', (res_normal rv))))
+      | None -> default))
+
+(** val creating_function_object_proto :
+    runs_type -> state -> execution_ctx -> object_loc -> result **)
+
+let creating_function_object_proto runs0 s c l =
+  if_object (run_construct_prealloc runs0 s c Coq_prealloc_object [])
+    (fun s1 lproto ->
+    let_binding { attributes_data_value = (Coq_value_object l);
+      attributes_data_writable = true; attributes_data_enumerable = false;
+      attributes_data_configurable = true } (fun a1 ->
+      if_bool
+        (object_define_own_prop runs0 s1 c lproto
+          ("constructor")
+          (descriptor_of_attributes (Coq_attributes_data_of a1)) false)
+        (fun s2 b ->
+        let_binding { attributes_data_value = (Coq_value_object lproto);
+          attributes_data_writable = true; attributes_data_enumerable =
+          false; attributes_data_configurable = false } (fun a2 ->
+          object_define_own_prop runs0 s2 c l
+            ("prototype")
+            (descriptor_of_attributes (Coq_attributes_data_of a2)) false))))
+
+(** val creating_function_object :
+    runs_type -> state -> execution_ctx -> char list list -> funcbody ->
+    lexical_env -> strictness_flag -> result **)
+
+let creating_function_object runs0 s c names bd x str =
+  let_binding
+    (object_new (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_function_proto))
+      ("Function")) (fun o ->
+    let_binding (object_with_get o Coq_builtin_get_function) (fun o1 ->
+      let_binding
+        (object_with_invokation o1 (Some Coq_construct_default) (Some
+          Coq_call_default) (Some Coq_builtin_has_instance_function))
+        (fun o2 ->
+        let_binding
+          (object_with_details o2 (Some x) (Some names) (Some bd) None None
+            None None) (fun o3 ->
+          let_binding (object_alloc s o3) (fun p ->
+            let (l, s1) = p in
+            let_binding { attributes_data_value = (Coq_value_prim
+              (Coq_prim_number
+              (of_int (my_Z_of_nat (LibList.length names)))));
+              attributes_data_writable = false; attributes_data_enumerable =
+              false; attributes_data_configurable = false } (fun a1 ->
+              if_bool
+                (object_define_own_prop runs0 s1 c l
+                  ("length")
+                  (descriptor_of_attributes (Coq_attributes_data_of a1))
+                  false) (fun s2 b2 ->
+                if_bool (creating_function_object_proto runs0 s2 c l)
+                  (fun s3 b3 ->
+                  if negb str
+                  then res_ter s3 (res_val (Coq_value_object l))
+                  else let_binding (Coq_value_object (Coq_object_loc_prealloc
+                         Coq_prealloc_throw_type_error)) (fun vthrower ->
+                         let_binding { attributes_accessor_get = vthrower;
+                           attributes_accessor_set = vthrower;
+                           attributes_accessor_enumerable = false;
+                           attributes_accessor_configurable = false }
+                           (fun a2 ->
+                           if_bool
+                             (object_define_own_prop runs0 s3 c l
+                               ("caller")
+                               (descriptor_of_attributes
+                                 (Coq_attributes_accessor_of a2)) false)
+                             (fun s4 b4 ->
+                             if_bool
+                               (object_define_own_prop runs0 s4 c l
+                                 ("arguments")
+                                 (descriptor_of_attributes
+                                   (Coq_attributes_accessor_of a2)) false)
+                               (fun s5 b5 ->
+                               res_ter s5 (res_val (Coq_value_object l))))))))))))))
+
+(** val binding_inst_formal_params :
+    runs_type -> state -> execution_ctx -> env_loc -> value list -> char list
+    list -> strictness_flag -> result_void **)
+
+let rec binding_inst_formal_params runs0 s c l args names str =
+  match names with
+  | [] -> res_void s
+  | argname :: names' ->
+    let_binding (hd (Coq_value_prim Coq_prim_undef) args) (fun v ->
+      let_binding (tl args) (fun args' ->
+        if_bool (env_record_has_binding runs0 s c l argname) (fun s1 hb ->
+          let_binding (fun s' ->
+            if_void
+              (env_record_set_mutable_binding runs0 s' c l argname v str)
+              (fun s'' ->
+              binding_inst_formal_params runs0 s'' c l args' names' str))
+            (fun follow ->
+            if hb
+            then follow s1
+            else if_void
+                   (env_record_create_mutable_binding runs0 s1 c l argname
+                     None) follow))))
+
+(** val binding_inst_function_decls :
+    runs_type -> state -> execution_ctx -> env_loc -> funcdecl list ->
+    strictness_flag -> bool -> result_void **)
+
+let rec binding_inst_function_decls runs0 s c l fds str bconfig =
+  match fds with
+  | [] -> res_void s
+  | fd :: fds' ->
+    let_binding fd.funcdecl_body (fun fbd ->
+      let_binding (funcbody_is_strict fbd) (fun str_fd ->
+        let_binding fd.funcdecl_parameters (fun fparams ->
+          let_binding fd.funcdecl_name (fun fname ->
+            if_object
+              (creating_function_object runs0 s c fparams fbd
+                c.execution_ctx_variable_env str_fd) (fun s1 fo ->
+              let_binding (fun s2 ->
+                if_void
+                  (env_record_set_mutable_binding runs0 s2 c l fname
+                    (Coq_value_object fo) str) (fun s3 ->
+                  binding_inst_function_decls runs0 s3 c l fds' str bconfig))
+                (fun follow ->
+                if_bool (env_record_has_binding runs0 s1 c l fname)
+                  (fun s2 has ->
+                  if has
+                  then if nat_comparable l env_loc_global_env_record
+                       then if_spec
+                              (run_object_get_prop runs0 s2 c
+                                (Coq_object_loc_prealloc Coq_prealloc_global)
+                                fname) (fun s3 d ->
+                              match d with
+                              | Coq_full_descriptor_undef ->
+                                (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                                  s3
+                                  ("Undefined full descriptor in [binding_inst_function_decls].")
+                              | Coq_full_descriptor_some a ->
+                                if bool_decidable (attributes_configurable a)
+                                then let_binding { attributes_data_value =
+                                       (Coq_value_prim Coq_prim_undef);
+                                       attributes_data_writable = true;
+                                       attributes_data_enumerable = true;
+                                       attributes_data_configurable =
+                                       bconfig } (fun a' ->
+                                       if_bool
+                                         (object_define_own_prop runs0 s3 c
+                                           (Coq_object_loc_prealloc
+                                           Coq_prealloc_global) fname
+                                           (descriptor_of_attributes
+                                             (Coq_attributes_data_of a'))
+                                           true) (fun s0 x -> follow s0))
+                                else if or_decidable
+                                          (descriptor_is_accessor_dec
+                                            (descriptor_of_attributes a))
+                                          (or_decidable
+                                            (bool_comparable
+                                              (attributes_writable a) false)
+                                            (bool_comparable
+                                              (attributes_enumerable a)
+                                              false))
+                                     then run_error s3 Coq_native_error_type
+                                     else follow s3)
+                       else follow s2
+                  else if_void
+                         (env_record_create_mutable_binding runs0 s2 c l
+                           fname (Some bconfig)) follow)))))))
+
+(** val make_arg_getter :
+    runs_type -> state -> execution_ctx -> prop_name -> lexical_env -> result **)
+
+let make_arg_getter runs0 s c x x0 =
+  let xbd =
+    append ("return ")
+      (append x (";"))
+  in
+  let bd = Coq_funcbody_intro ((Coq_prog_intro (true, ((Coq_element_stat
+    (Coq_stat_return (Some (Coq_expr_identifier x)))) :: []))), xbd)
+  in
+  creating_function_object runs0 s c [] bd x0 true
+
+(** val make_arg_setter :
+    runs_type -> state -> execution_ctx -> prop_name -> lexical_env -> result **)
+
+let make_arg_setter runs0 s c x x0 =
+  let xparam = append x ("_arg") in
+  let xbd =
+    append x (append (" = ") (append xparam (';'::[])))
+  in
+  let bd = Coq_funcbody_intro ((Coq_prog_intro (true, ((Coq_element_stat
+    (Coq_stat_expr (Coq_expr_assign ((Coq_expr_identifier x), None,
+    (Coq_expr_identifier xparam))))) :: []))), xbd)
+  in
+  creating_function_object runs0 s c (xparam :: []) bd x0 true
+
+(** val arguments_object_map_loop :
+    runs_type -> state -> execution_ctx -> object_loc -> char list list ->
+    int -> value list -> lexical_env -> strictness_flag -> object_loc ->
+    char list list -> result_void **)
+
+let rec arguments_object_map_loop runs0 s c l xs len args x str lmap xsmap =
+  (fun fO fS n -> if n=0 then fO () else fS (n-1))
+    (fun _ ->
+    if list_eq_nil_decidable xsmap
+    then res_void s
+    else if_some (object_binds_pickable_option s l) (fun o ->
+           let_binding
+             (object_for_args_object o lmap Coq_builtin_get_args_obj
+               Coq_builtin_get_own_prop_args_obj
+               Coq_builtin_define_own_prop_args_obj
+               Coq_builtin_delete_args_obj) (fun o' ->
+             res_void (object_write s l o'))))
+    (fun len' ->
+    let_binding (take_drop_last args) (fun tdl ->
+      let (rmlargs, largs) = tdl in
+      let_binding (fun s0 xsmap0 ->
+        arguments_object_map_loop runs0 s0 c l xs len' rmlargs x str lmap
+          xsmap0) (fun arguments_object_map_loop' ->
+        let_binding (attributes_data_intro_all_true largs) (fun a ->
+          if_bool
+            (object_define_own_prop runs0 s c l
+              (convert_prim_to_string (Coq_prim_number
+                (of_int (my_Z_of_nat len'))))
+              (descriptor_of_attributes (Coq_attributes_data_of a)) false)
+            (fun s1 b ->
+            if ge_nat_decidable len' (LibList.length xs)
+            then arguments_object_map_loop' s1 xsmap
+            else let dummy = [] in
+                 let_binding (nth_def dummy len' xs) (fun x0 ->
+                   if or_decidable (bool_comparable str true)
+                        (coq_Mem_decidable string_comparable x0 xsmap)
+                   then arguments_object_map_loop' s1 xsmap
+                   else if_object (make_arg_getter runs0 s1 c x0 x)
+                          (fun s2 lgetter ->
+                          if_object (make_arg_setter runs0 s2 c x0 x)
+                            (fun s3 lsetter ->
+                            let_binding { attributes_accessor_get =
+                              (Coq_value_object lgetter);
+                              attributes_accessor_set = (Coq_value_object
+                              lsetter); attributes_accessor_enumerable =
+                              false; attributes_accessor_configurable =
+                              true } (fun a' ->
+                              if_bool
+                                (object_define_own_prop runs0 s3 c lmap
+                                  (convert_prim_to_string (Coq_prim_number
+                                    (of_int (my_Z_of_nat len'))))
+                                  (descriptor_of_attributes
+                                    (Coq_attributes_accessor_of a')) false)
+                                (fun s4 b' ->
+                                arguments_object_map_loop' s4 (x0 :: xsmap)))))))))))
+    len
+
+(** val arguments_object_map :
+    runs_type -> state -> execution_ctx -> object_loc -> char list list ->
+    value list -> lexical_env -> strictness_flag -> result_void **)
+
+let arguments_object_map runs0 s c l xs args x str =
+  if_object (run_construct_prealloc runs0 s c Coq_prealloc_object [])
+    (fun s' lmap ->
+    arguments_object_map_loop runs0 s' c l xs (LibList.length args) args x
+      str lmap [])
+
+(** val create_arguments_object :
+    runs_type -> state -> execution_ctx -> object_loc -> char list list ->
+    value list -> lexical_env -> strictness_flag -> result **)
+
+let create_arguments_object runs0 s c lf xs args x str =
+  let_binding
+    (object_create_builtin (Coq_value_object (Coq_object_loc_prealloc
+      Coq_prealloc_object_proto))
+      ("Arguments")
+      Heap.empty) (fun o ->
+    let_binding (object_alloc s o) (fun p ->
+      let (l, s') = p in
+      let_binding { attributes_data_value = (Coq_value_prim (Coq_prim_number
+        (of_int (my_Z_of_nat (LibList.length args)))));
+        attributes_data_writable = true; attributes_data_enumerable = false;
+        attributes_data_configurable = true } (fun a ->
+        if_bool
+          (object_define_own_prop runs0 s' c l
+            ("length")
+            (descriptor_of_attributes (Coq_attributes_data_of a)) false)
+          (fun s1 b ->
+          if_void (arguments_object_map runs0 s1 c l xs args x str)
+            (fun s2 ->
+            if str
+            then let_binding (Coq_value_object (Coq_object_loc_prealloc
+                   Coq_prealloc_throw_type_error)) (fun vthrower ->
+                   let_binding { attributes_accessor_get = vthrower;
+                     attributes_accessor_set = vthrower;
+                     attributes_accessor_enumerable = false;
+                     attributes_accessor_configurable = false } (fun a0 ->
+                     if_bool
+                       (object_define_own_prop runs0 s2 c l
+                         ("caller")
+                         (descriptor_of_attributes
+                           (Coq_attributes_accessor_of a0)) false)
+                       (fun s3 b' ->
+                       if_bool
+                         (object_define_own_prop runs0 s3 c l
+                           ("callee")
+                           (descriptor_of_attributes
+                             (Coq_attributes_accessor_of a0)) false)
+                         (fun s4 b'' ->
+                         res_ter s4 (res_val (Coq_value_object l))))))
+            else let_binding { attributes_data_value = (Coq_value_object lf);
+                   attributes_data_writable = true;
+                   attributes_data_enumerable = false;
+                   attributes_data_configurable = true } (fun a0 ->
+                   if_bool
+                     (object_define_own_prop runs0 s2 c l
+                       ("callee")
+                       (descriptor_of_attributes (Coq_attributes_data_of a0))
+                       false) (fun s3 b' ->
+                     res_ter s3 (res_val (Coq_value_object l)))))))))
+
+(** val binding_inst_arg_obj :
+    runs_type -> state -> execution_ctx -> object_loc -> prog -> char list
+    list -> value list -> env_loc -> result_void **)
+
+let binding_inst_arg_obj runs0 s c lf p xs args l =
+  let arguments =
+    "arguments"
+  in
+  let_binding (prog_intro_strictness p) (fun str ->
+    if_object
+      (create_arguments_object runs0 s c lf xs args
+        c.execution_ctx_variable_env str) (fun s1 largs ->
+      if str
+      then if_void (env_record_create_immutable_binding s1 l arguments)
+             (fun s2 ->
+             env_record_initialize_immutable_binding s2 l arguments
+               (Coq_value_object largs))
+      else env_record_create_set_mutable_binding runs0 s1 c l arguments None
+             (Coq_value_object largs) false))
+
+(** val binding_inst_var_decls :
+    runs_type -> state -> execution_ctx -> env_loc -> char list list -> bool
+    -> strictness_flag -> result_void **)
+
+let rec binding_inst_var_decls runs0 s c l vds bconfig str =
+  match vds with
+  | [] -> res_void s
+  | vd :: vds' ->
+    let_binding (fun s0 ->
+      binding_inst_var_decls runs0 s0 c l vds' bconfig str) (fun bivd ->
+      if_bool (env_record_has_binding runs0 s c l vd) (fun s1 has ->
+        if has
+        then bivd s1
+        else if_void
+               (env_record_create_set_mutable_binding runs0 s1 c l vd (Some
+                 bconfig) (Coq_value_prim Coq_prim_undef) str) bivd))
+
+(** val execution_ctx_binding_inst :
+    runs_type -> state -> execution_ctx -> codetype -> object_loc option ->
+    prog -> value list -> result_void **)
+
+let execution_ctx_binding_inst runs0 s c ct funco p args =
+  match c.execution_ctx_variable_env with
+  | [] ->
+    (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+      s
+      ("Empty [execution_ctx_variable_env] in [execution_ctx_binding_inst].")
+  | l :: l0 ->
+    let_binding (prog_intro_strictness p) (fun str ->
+      let_binding (fun s' names ->
+        let_binding (codetype_comparable ct Coq_codetype_eval)
+          (fun bconfig ->
+          let_binding (prog_funcdecl p) (fun fds ->
+            if_void
+              (binding_inst_function_decls runs0 s' c l fds str bconfig)
+              (fun s1 ->
+              if_bool
+                (env_record_has_binding runs0 s1 c l
+                  ("arguments"))
+                (fun s2 bdefined ->
+                let_binding (fun s'0 ->
+                  let vds = prog_vardecl p in
+                  binding_inst_var_decls runs0 s'0 c l vds bconfig str)
+                  (fun follow2 ->
+                  match ct with
+                  | Coq_codetype_func ->
+                    (match funco with
+                     | Some func ->
+                       if bdefined
+                       then follow2 s2
+                       else if_void
+                              (binding_inst_arg_obj runs0 s2 c func p names
+                                args l) follow2
+                     | None ->
+                       if bdefined
+                       then follow2 s2
+                       else (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                              s2
+                              ("Weird `arguments\' object in [execution_ctx_binding_inst]."))
+                  | Coq_codetype_global -> follow2 s2
+                  | Coq_codetype_eval -> follow2 s2)))))) (fun follow ->
+        match ct with
+        | Coq_codetype_func ->
+          (match funco with
+           | Some func ->
+             if_some (run_object_method object_formal_parameters_ s func)
+               (fun nameso ->
+               if_some nameso (fun names ->
+                 if_void
+                   (binding_inst_formal_params runs0 s c l args names str)
+                   (fun s' -> follow s' names)))
+           | None ->
+             (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+               s
+               ("Non coherent functionnal code type in [execution_ctx_binding_inst]."))
+        | Coq_codetype_global ->
+          (match funco with
+           | Some o ->
+             (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+               s
+               ("Non coherent non-functionnal code type in [execution_ctx_binding_inst].")
+           | None -> follow s [])
+        | Coq_codetype_eval ->
+          (match funco with
+           | Some o ->
+             (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+               s
+               ("Non coherent non-functionnal code type in [execution_ctx_binding_inst].")
+           | None -> follow s [])))
+
+(** val entering_func_code :
+    runs_type -> state -> execution_ctx -> object_loc -> value -> value list
+    -> result **)
+
+let entering_func_code runs0 s c lf vthis args =
+  if_some (run_object_method object_code_ s lf) (fun bdo ->
+    if_some bdo (fun bd ->
+      let_binding (funcbody_is_strict bd) (fun str ->
+        let_binding (fun s' vthis' ->
+          if_some (run_object_method object_scope_ s' lf) (fun lexo ->
+            if_some lexo (fun lex ->
+              let_binding (lexical_env_alloc_decl s' lex) (fun p ->
+                let (lex', s1) = p in
+                let_binding (execution_ctx_intro_same lex' vthis' str)
+                  (fun c' ->
+                  if_void
+                    (execution_ctx_binding_inst runs0 s1 c' Coq_codetype_func
+                      (Some lf) (funcbody_prog bd) args) (fun s2 ->
+                    run_call_default runs0 s2 c' lf)))))) (fun follow ->
+          if str
+          then follow s vthis
+          else (match vthis with
+                | Coq_value_prim p ->
+                  (match p with
+                   | Coq_prim_undef ->
+                     follow s (Coq_value_object (Coq_object_loc_prealloc
+                       Coq_prealloc_global))
+                   | Coq_prim_null ->
+                     follow s (Coq_value_object (Coq_object_loc_prealloc
+                       Coq_prealloc_global))
+                   | Coq_prim_bool b -> if_value (to_object s vthis) follow
+                   | Coq_prim_number n -> if_value (to_object s vthis) follow
+                   | Coq_prim_string s0 ->
+                     if_value (to_object s vthis) follow)
+                | Coq_value_object lthis -> follow s vthis)))))
+
+(** val run_object_get_own_prop :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name ->
+    full_descriptor specres **)
+
+let run_object_get_own_prop runs0 s c l x =
+  if_some (run_object_method object_get_own_prop_ s l) (fun b ->
+    let_binding (fun s' ->
+      if_some (run_object_method object_properties_ s' l) (fun p ->
+        res_spec s'
+          (if_some_or_default
+            (convert_option_attributes
+              (Heap.read_option string_comparable p x))
+            Coq_full_descriptor_undef id))) (fun default ->
+      match b with
+      | Coq_builtin_get_own_prop_default -> default s
+      | Coq_builtin_get_own_prop_args_obj ->
+        if_spec (default s) (fun s1 d ->
+          match d with
+          | Coq_full_descriptor_undef ->
+            res_spec s1 Coq_full_descriptor_undef
+          | Coq_full_descriptor_some a ->
+            if_some (run_object_method object_parameter_map_ s1 l)
+              (fun lmapo ->
+              if_some lmapo (fun lmap ->
+                if_spec (runs0.runs_type_object_get_own_prop s1 c lmap x)
+                  (fun s2 d0 ->
+                  let_binding (fun s' a0 ->
+                    res_spec s' (Coq_full_descriptor_some a0)) (fun follow ->
+                    match d0 with
+                    | Coq_full_descriptor_undef -> follow s2 a
+                    | Coq_full_descriptor_some amap ->
+                      if_value (run_object_get runs0 s2 c lmap x)
+                        (fun s3 v ->
+                        match a with
+                        | Coq_attributes_data_of ad ->
+                          follow s3 (Coq_attributes_data_of
+                            (attributes_data_with_value ad v))
+                        | Coq_attributes_accessor_of aa ->
+                          (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                            s3
+                            ("[run_object_get_own_prop]:  received an accessor property descriptor in a point where the specification suppose it never happens.")))))))
+      | Coq_builtin_get_own_prop_string ->
+        if_spec (default s) (fun s0 d ->
+          match d with
+          | Coq_full_descriptor_undef ->
+            if_spec
+              (to_int32 runs0 s0 c (Coq_value_prim (Coq_prim_string x)))
+              (fun s1 k ->
+              if_string
+                (runs0.runs_type_to_string s1 c (Coq_value_prim
+                  (Coq_prim_number (of_int (my_Z_of_nat (Z.abs_nat k))))))
+                (fun s2 s3 ->
+                if not_decidable (string_comparable x s3)
+                then res_spec s2 Coq_full_descriptor_undef
+                else if_string (run_object_prim_value s2 l) (fun s4 str ->
+                       if_spec
+                         (to_int32 runs0 s4 c (Coq_value_prim
+                           (Coq_prim_string x))) (fun s5 k0 ->
+                         let_binding (Z.of_nat (length str)) (fun len ->
+                           if le_int_decidable len k0
+                           then res_spec s5 Coq_full_descriptor_undef
+                           else let resultStr =
+                                  string_sub str k0
+                                    (my_Z_of_nat (Pervasives.succ 0))
+                                in
+                                let a = { attributes_data_value =
+                                  (Coq_value_prim (Coq_prim_string
+                                  resultStr)); attributes_data_writable =
+                                  false; attributes_data_enumerable = true;
+                                  attributes_data_configurable = false }
+                                in
+                                res_spec s5 (Coq_full_descriptor_some
+                                  (Coq_attributes_data_of a)))))))
+          | Coq_full_descriptor_some a -> res_spec s0 d)))
+
+(** val run_function_has_instance :
+    runs_type -> state -> object_loc -> value -> result **)
+
+let run_function_has_instance runs0 s lv = function
+| Coq_value_prim p -> run_error s Coq_native_error_type
+| Coq_value_object lo ->
+  if_some (run_object_method object_proto_ s lv) (fun vproto ->
+    match vproto with
+    | Coq_value_prim p ->
+      (match p with
+       | Coq_prim_undef ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("Primitive found in the prototype chain in [run_object_has_instance_loop].")
+       | Coq_prim_null ->
+         res_ter s (res_val (Coq_value_prim (Coq_prim_bool false)))
+       | Coq_prim_bool b ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("Primitive found in the prototype chain in [run_object_has_instance_loop].")
+       | Coq_prim_number n ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("Primitive found in the prototype chain in [run_object_has_instance_loop].")
+       | Coq_prim_string s0 ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("Primitive found in the prototype chain in [run_object_has_instance_loop]."))
+    | Coq_value_object proto ->
+      if object_loc_comparable proto lo
+      then res_ter s (res_val (Coq_value_prim (Coq_prim_bool true)))
+      else runs0.runs_type_function_has_instance s proto (Coq_value_object
+             lo))
+
+(** val run_object_has_instance :
+    runs_type -> state -> execution_ctx -> builtin_has_instance -> object_loc
+    -> value -> result **)
+
+let run_object_has_instance runs0 s c b l v =
+  match b with
+  | Coq_builtin_has_instance_function ->
+    (match v with
+     | Coq_value_prim w ->
+       result_out (Coq_out_ter (s,
+         (res_val (Coq_value_prim (Coq_prim_bool false)))))
+     | Coq_value_object lv ->
+       if_value
+         (run_object_get runs0 s c l
+           ("prototype"))
+         (fun s1 vproto ->
+         match vproto with
+         | Coq_value_prim p -> run_error s1 Coq_native_error_type
+         | Coq_value_object lproto ->
+           runs0.runs_type_function_has_instance s1 lv (Coq_value_object
+             lproto)))
+  | Coq_builtin_has_instance_after_bind ->
+    if_some (run_object_method object_target_function_ s l) (fun ol ->
+      if_some ol (fun l0 ->
+        if_some (run_object_method object_has_instance_ s l0) (fun ob ->
+          match ob with
+          | Some b0 -> runs0.runs_type_object_has_instance s c b0 l0 v
+          | None -> run_error s Coq_native_error_type)))
+
+(** val from_prop_descriptor :
+    runs_type -> state -> execution_ctx -> full_descriptor -> result **)
+
+let from_prop_descriptor runs0 s c = function
+| Coq_full_descriptor_undef ->
+  result_out (Coq_out_ter (s, (res_val (Coq_value_prim Coq_prim_undef))))
+| Coq_full_descriptor_some a ->
+  if_object (run_construct_prealloc runs0 s c Coq_prealloc_object [])
+    (fun s1 l ->
+    let_binding (fun s0 x ->
+      let_binding
+        (attributes_data_intro_all_true (Coq_value_prim (Coq_prim_bool
+          (attributes_enumerable a)))) (fun a1 ->
+        if_bool
+          (object_define_own_prop runs0 s0 c l
+            ("enumerable")
+            (descriptor_of_attributes (Coq_attributes_data_of a1))
+            throw_false) (fun s0' x0 ->
+          let_binding
+            (attributes_data_intro_all_true (Coq_value_prim (Coq_prim_bool
+              (attributes_configurable a)))) (fun a2 ->
+            if_bool
+              (object_define_own_prop runs0 s0' c l
+                ("configurable")
+                (descriptor_of_attributes (Coq_attributes_data_of a2))
+                throw_false) (fun s' x1 ->
+              res_ter s' (res_val (Coq_value_object l))))))) (fun follow ->
+      match a with
+      | Coq_attributes_data_of ad ->
+        let_binding (attributes_data_intro_all_true ad.attributes_data_value)
+          (fun a1 ->
+          if_bool
+            (object_define_own_prop runs0 s1 c l
+              ("value")
+              (descriptor_of_attributes (Coq_attributes_data_of a1))
+              throw_false) (fun s2 x ->
+            let_binding
+              (attributes_data_intro_all_true (Coq_value_prim (Coq_prim_bool
+                ad.attributes_data_writable))) (fun a2 ->
+              if_bool
+                (object_define_own_prop runs0 s2 c l
+                  ("writable")
+                  (descriptor_of_attributes (Coq_attributes_data_of a2))
+                  throw_false) follow)))
+      | Coq_attributes_accessor_of aa ->
+        let_binding
+          (attributes_data_intro_all_true aa.attributes_accessor_get)
+          (fun a1 ->
+          if_bool
+            (object_define_own_prop runs0 s1 c l ("get")
+              (descriptor_of_attributes (Coq_attributes_data_of a1))
+              throw_false) (fun s2 x ->
+            let_binding
+              (attributes_data_intro_all_true aa.attributes_accessor_set)
+              (fun a2 ->
+              if_bool
+                (object_define_own_prop runs0 s2 c l ("set")
+                  (descriptor_of_attributes (Coq_attributes_data_of a2))
+                  throw_false) follow)))))
+
+(** val is_lazy_op : binary_op -> bool option **)
+
+let is_lazy_op = function
+| Coq_binary_op_mult -> None
+| Coq_binary_op_div -> None
+| Coq_binary_op_mod -> None
+| Coq_binary_op_add -> None
+| Coq_binary_op_sub -> None
+| Coq_binary_op_left_shift -> None
+| Coq_binary_op_right_shift -> None
+| Coq_binary_op_unsigned_right_shift -> None
+| Coq_binary_op_lt -> None
+| Coq_binary_op_gt -> None
+| Coq_binary_op_le -> None
+| Coq_binary_op_ge -> None
+| Coq_binary_op_instanceof -> None
+| Coq_binary_op_in -> None
+| Coq_binary_op_equal -> None
+| Coq_binary_op_disequal -> None
+| Coq_binary_op_strict_equal -> None
+| Coq_binary_op_strict_disequal -> None
+| Coq_binary_op_bitwise_and -> None
+| Coq_binary_op_bitwise_or -> None
+| Coq_binary_op_bitwise_xor -> None
+| Coq_binary_op_and -> Some false
+| Coq_binary_op_or -> Some true
+| Coq_binary_op_coma -> None
+
+(** val get_puremath_op :
+    binary_op -> (number -> number -> number) option **)
+
+let get_puremath_op = function
+| Coq_binary_op_mult -> Some mult
+| Coq_binary_op_div -> Some div
+| Coq_binary_op_mod -> Some fmod
+| Coq_binary_op_add -> None
+| Coq_binary_op_sub -> Some sub
+| Coq_binary_op_left_shift -> None
+| Coq_binary_op_right_shift -> None
+| Coq_binary_op_unsigned_right_shift -> None
+| Coq_binary_op_lt -> None
+| Coq_binary_op_gt -> None
+| Coq_binary_op_le -> None
+| Coq_binary_op_ge -> None
+| Coq_binary_op_instanceof -> None
+| Coq_binary_op_in -> None
+| Coq_binary_op_equal -> None
+| Coq_binary_op_disequal -> None
+| Coq_binary_op_strict_equal -> None
+| Coq_binary_op_strict_disequal -> None
+| Coq_binary_op_bitwise_and -> None
+| Coq_binary_op_bitwise_or -> None
+| Coq_binary_op_bitwise_xor -> None
+| Coq_binary_op_and -> None
+| Coq_binary_op_or -> None
+| Coq_binary_op_coma -> None
+
+(** val get_inequality_op : binary_op -> (bool * bool) option **)
+
+let get_inequality_op = function
+| Coq_binary_op_mult -> None
+| Coq_binary_op_div -> None
+| Coq_binary_op_mod -> None
+| Coq_binary_op_add -> None
+| Coq_binary_op_sub -> None
+| Coq_binary_op_left_shift -> None
+| Coq_binary_op_right_shift -> None
+| Coq_binary_op_unsigned_right_shift -> None
+| Coq_binary_op_lt -> Some (false, false)
+| Coq_binary_op_gt -> Some (true, false)
+| Coq_binary_op_le -> Some (true, true)
+| Coq_binary_op_ge -> Some (false, true)
+| Coq_binary_op_instanceof -> None
+| Coq_binary_op_in -> None
+| Coq_binary_op_equal -> None
+| Coq_binary_op_disequal -> None
+| Coq_binary_op_strict_equal -> None
+| Coq_binary_op_strict_disequal -> None
+| Coq_binary_op_bitwise_and -> None
+| Coq_binary_op_bitwise_or -> None
+| Coq_binary_op_bitwise_xor -> None
+| Coq_binary_op_and -> None
+| Coq_binary_op_or -> None
+| Coq_binary_op_coma -> None
+
+(** val get_shift_op :
+    binary_op -> (bool * (float -> float -> float)) option **)
+
+let get_shift_op = function
+| Coq_binary_op_mult -> None
+| Coq_binary_op_div -> None
+| Coq_binary_op_mod -> None
+| Coq_binary_op_add -> None
+| Coq_binary_op_sub -> None
+| Coq_binary_op_left_shift -> Some (false, int32_left_shift)
+| Coq_binary_op_right_shift -> Some (false, int32_right_shift)
+| Coq_binary_op_unsigned_right_shift -> Some (true, uint32_right_shift)
+| Coq_binary_op_lt -> None
+| Coq_binary_op_gt -> None
+| Coq_binary_op_le -> None
+| Coq_binary_op_ge -> None
+| Coq_binary_op_instanceof -> None
+| Coq_binary_op_in -> None
+| Coq_binary_op_equal -> None
+| Coq_binary_op_disequal -> None
+| Coq_binary_op_strict_equal -> None
+| Coq_binary_op_strict_disequal -> None
+| Coq_binary_op_bitwise_and -> None
+| Coq_binary_op_bitwise_or -> None
+| Coq_binary_op_bitwise_xor -> None
+| Coq_binary_op_and -> None
+| Coq_binary_op_or -> None
+| Coq_binary_op_coma -> None
+
+(** val get_bitwise_op : binary_op -> (float -> float -> float) option **)
+
+let get_bitwise_op = function
+| Coq_binary_op_mult -> None
+| Coq_binary_op_div -> None
+| Coq_binary_op_mod -> None
+| Coq_binary_op_add -> None
+| Coq_binary_op_sub -> None
+| Coq_binary_op_left_shift -> None
+| Coq_binary_op_right_shift -> None
+| Coq_binary_op_unsigned_right_shift -> None
+| Coq_binary_op_lt -> None
+| Coq_binary_op_gt -> None
+| Coq_binary_op_le -> None
+| Coq_binary_op_ge -> None
+| Coq_binary_op_instanceof -> None
+| Coq_binary_op_in -> None
+| Coq_binary_op_equal -> None
+| Coq_binary_op_disequal -> None
+| Coq_binary_op_strict_equal -> None
+| Coq_binary_op_strict_disequal -> None
+| Coq_binary_op_bitwise_and -> Some int32_bitwise_and
+| Coq_binary_op_bitwise_or -> Some int32_bitwise_or
+| Coq_binary_op_bitwise_xor -> Some int32_bitwise_xor
+| Coq_binary_op_and -> None
+| Coq_binary_op_or -> None
+| Coq_binary_op_coma -> None
+
+(** val run_equal :
+    runs_type -> state -> execution_ctx -> value -> value -> result **)
+
+let run_equal runs0 s c v1 v2 =
+  let conv_number = fun s0 v -> to_number runs0 s0 c v in
+  let conv_primitive = fun s0 v -> to_primitive runs0 s0 c v None in
+  let_binding (fun s0 v3 v4 k ->
+    let ty1 = type_of v3 in
+    let ty2 = type_of v4 in
+    if type_comparable ty1 ty2
+    then result_out (Coq_out_ter (s0,
+           (res_val (Coq_value_prim (Coq_prim_bool
+             (equality_test_for_same_type ty1 v3 v4))))))
+    else k ty1 ty2) (fun checkTypesThen ->
+    checkTypesThen s v1 v2 (fun ty1 ty2 ->
+      let_binding (fun v3 f v4 ->
+        if_value (f s v4) (fun s0 v2' -> runs0.runs_type_equal s0 c v3 v2'))
+        (fun dc_conv ->
+        let so = fun b ->
+          result_out (Coq_out_ter (s,
+            (res_val (Coq_value_prim (Coq_prim_bool b)))))
+        in
+        if and_decidable (type_comparable ty1 Coq_type_null)
+             (type_comparable ty2 Coq_type_undef)
+        then so true
+        else if and_decidable (type_comparable ty1 Coq_type_undef)
+                  (type_comparable ty2 Coq_type_null)
+             then so true
+             else if and_decidable (type_comparable ty1 Coq_type_number)
+                       (type_comparable ty2 Coq_type_string)
+                  then dc_conv v1 conv_number v2
+                  else if and_decidable (type_comparable ty1 Coq_type_string)
+                            (type_comparable ty2 Coq_type_number)
+                       then dc_conv v2 conv_number v1
+                       else if type_comparable ty1 Coq_type_bool
+                            then dc_conv v2 conv_number v1
+                            else if type_comparable ty2 Coq_type_bool
+                                 then dc_conv v1 conv_number v2
+                                 else if and_decidable
+                                           (or_decidable
+                                             (type_comparable ty1
+                                               Coq_type_string)
+                                             (type_comparable ty1
+                                               Coq_type_number))
+                                           (type_comparable ty2
+                                             Coq_type_object)
+                                      then dc_conv v1 conv_primitive v2
+                                      else if and_decidable
+                                                (type_comparable ty1
+                                                  Coq_type_object)
+                                                (or_decidable
+                                                  (type_comparable ty2
+                                                    Coq_type_string)
+                                                  (type_comparable ty2
+                                                    Coq_type_number))
+                                           then dc_conv v2 conv_primitive v1
+                                           else so false)))
+
+(** val convert_twice :
+    ('a2 resultof -> (state -> 'a1 -> ('a1 * 'a1) specres) -> ('a1 * 'a1)
+    specres) -> (state -> value -> 'a2 resultof) -> state -> value -> value
+    -> ('a1 * 'a1) specres **)
+
+let convert_twice ifv kC s v1 v2 =
+  ifv (kC s v1) (fun s1 vc1 ->
+    ifv (kC s1 v2) (fun s2 vc2 -> res_spec s2 (vc1, vc2)))
+
+(** val convert_twice_primitive :
+    runs_type -> state -> execution_ctx -> value -> value -> (prim * prim)
+    specres **)
+
+let convert_twice_primitive runs0 s c v1 v2 =
+  convert_twice if_prim (fun s0 v -> to_primitive runs0 s0 c v None) s v1 v2
+
+(** val convert_twice_number :
+    runs_type -> state -> execution_ctx -> value -> value ->
+    (number * number) specres **)
+
+let convert_twice_number runs0 s c v1 v2 =
+  convert_twice if_number (fun s0 v -> to_number runs0 s0 c v) s v1 v2
+
+(** val convert_twice_string :
+    runs_type -> state -> execution_ctx -> value -> value ->
+    (char list * char list) specres **)
+
+let convert_twice_string runs0 s c v1 v2 =
+  convert_twice if_string (fun s0 v -> to_string runs0 s0 c v) s v1 v2
+
+(** val issome : 'a1 option -> bool **)
+
+let issome = function
+| Some t -> true
+| None -> false
+
+(** val run_binary_op :
+    runs_type -> state -> execution_ctx -> binary_op -> value -> value ->
+    result **)
+
+let run_binary_op runs0 s c op v1 v2 =
+  if binary_op_comparable op Coq_binary_op_add
+  then if_spec (convert_twice_primitive runs0 s c v1 v2) (fun s1 ww ->
+         let (w1, w2) = ww in
+         if or_decidable
+              (type_comparable (type_of (Coq_value_prim w1)) Coq_type_string)
+              (type_comparable (type_of (Coq_value_prim w2)) Coq_type_string)
+         then if_spec
+                (convert_twice_string runs0 s1 c (Coq_value_prim w1)
+                  (Coq_value_prim w2)) (fun s2 ss ->
+                let (s3, s4) = ss in
+                res_out (Coq_out_ter (s2,
+                  (res_val (Coq_value_prim (Coq_prim_string (append s3 s4)))))))
+         else if_spec
+                (convert_twice_number runs0 s1 c (Coq_value_prim w1)
+                  (Coq_value_prim w2)) (fun s2 nn ->
+                let (n1, n2) = nn in
+                res_out (Coq_out_ter (s2,
+                  (res_val (Coq_value_prim (Coq_prim_number (add n1 n2))))))))
+  else if issome (get_puremath_op op)
+       then if_some (get_puremath_op op) (fun mop ->
+              if_spec (convert_twice_number runs0 s c v1 v2) (fun s1 nn ->
+                let (n1, n2) = nn in
+                res_out (Coq_out_ter (s1,
+                  (res_val (Coq_value_prim (Coq_prim_number (mop n1 n2))))))))
+       else if issome (get_shift_op op)
+            then if_some (get_shift_op op) (fun so ->
+                   let (b_unsigned, f) = so in
+                   if_spec
+                     ((if b_unsigned then to_uint32 else to_int32) runs0 s c
+                       v1) (fun s1 k1 ->
+                     if_spec (to_uint32 runs0 s1 c v2) (fun s2 k2 ->
+                       let k2' = modulo_32 k2 in
+                       res_ter s2
+                         (res_val (Coq_value_prim (Coq_prim_number
+                           (of_int (f k1 k2'))))))))
+            else if issome (get_bitwise_op op)
+                 then if_some (get_bitwise_op op) (fun bo ->
+                        if_spec (to_int32 runs0 s c v1) (fun s1 k1 ->
+                          if_spec (to_int32 runs0 s1 c v2) (fun s2 k2 ->
+                            res_ter s2
+                              (res_val (Coq_value_prim (Coq_prim_number
+                                (of_int (bo k1 k2))))))))
+                 else if issome (get_inequality_op op)
+                      then if_some (get_inequality_op op) (fun io ->
+                             let (b_swap, b_neg) = io in
+                             if_spec
+                               (convert_twice_primitive runs0 s c v1 v2)
+                               (fun s1 ww ->
+                               let (w1, w2) = ww in
+                               let_binding
+                                 (if b_swap then (w2, w1) else (w1, w2))
+                                 (fun p ->
+                                 let (wa, wb) = p in
+                                 let wr = inequality_test_primitive wa wb in
+                                 res_out (Coq_out_ter (s1,
+                                   (if prim_comparable wr Coq_prim_undef
+                                    then res_val (Coq_value_prim
+                                           (Coq_prim_bool false))
+                                    else if and_decidable
+                                              (bool_comparable b_neg true)
+                                              (prim_comparable wr
+                                                (Coq_prim_bool true))
+                                         then res_val (Coq_value_prim
+                                                (Coq_prim_bool false))
+                                         else if and_decidable
+                                                   (bool_comparable b_neg
+                                                     true)
+                                                   (prim_comparable wr
+                                                     (Coq_prim_bool false))
+                                              then res_val (Coq_value_prim
+                                                     (Coq_prim_bool true))
+                                              else res_val (Coq_value_prim
+                                                     wr)))))))
+                      else if binary_op_comparable op
+                                Coq_binary_op_instanceof
+                           then (match v2 with
+                                 | Coq_value_prim p ->
+                                   run_error s Coq_native_error_type
+                                 | Coq_value_object l ->
+                                   if_some
+                                     (run_object_method object_has_instance_
+                                       s l) (fun b ->
+                                     option_case (fun x ->
+                                       run_error s Coq_native_error_type)
+                                       (fun has_instance_id x ->
+                                       run_object_has_instance runs0 s c
+                                         has_instance_id l v1) b ()))
+                           else if binary_op_comparable op Coq_binary_op_in
+                                then (match v2 with
+                                      | Coq_value_prim p ->
+                                        run_error s Coq_native_error_type
+                                      | Coq_value_object l ->
+                                        if_string (to_string runs0 s c v1)
+                                          (fun s2 x ->
+                                          object_has_prop runs0 s2 c l x))
+                                else if binary_op_comparable op
+                                          Coq_binary_op_equal
+                                     then runs0.runs_type_equal s c v1 v2
+                                     else if binary_op_comparable op
+                                               Coq_binary_op_disequal
+                                          then if_bool
+                                                 (runs0.runs_type_equal s c
+                                                   v1 v2) (fun s0 b0 ->
+                                                 res_ter s0
+                                                   (res_val (Coq_value_prim
+                                                     (Coq_prim_bool
+                                                     (negb b0)))))
+                                          else if binary_op_comparable op
+                                                    Coq_binary_op_strict_equal
+                                               then result_out (Coq_out_ter
+                                                      (s,
+                                                      (res_val
+                                                        (Coq_value_prim
+                                                        (Coq_prim_bool
+                                                        (strict_equality_test
+                                                          v1 v2))))))
+                                               else if binary_op_comparable
+                                                         op
+                                                         Coq_binary_op_strict_disequal
+                                                    then result_out
+                                                           (Coq_out_ter (s,
+                                                           (res_val
+                                                             (Coq_value_prim
+                                                             (Coq_prim_bool
+                                                             (negb
+                                                               (strict_equality_test
+                                                                 v1 v2)))))))
+                                                    else if binary_op_comparable
+                                                              op
+                                                              Coq_binary_op_coma
+                                                         then result_out
+                                                                (Coq_out_ter
+                                                                (s,
+                                                                (res_val v2)))
+                                                         else (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                                                                s
+                                                                ("Undealt lazy operator in [run_binary_op].")
+
+(** val run_prepost_op : unary_op -> ((number -> number) * bool) option **)
+
+let run_prepost_op = function
+| Coq_unary_op_delete -> None
+| Coq_unary_op_void -> None
+| Coq_unary_op_typeof -> None
+| Coq_unary_op_post_incr -> Some (add_one, false)
+| Coq_unary_op_post_decr -> Some (sub_one, false)
+| Coq_unary_op_pre_incr -> Some (add_one, true)
+| Coq_unary_op_pre_decr -> Some (sub_one, true)
+| Coq_unary_op_add -> None
+| Coq_unary_op_neg -> None
+| Coq_unary_op_bitwise_not -> None
+| Coq_unary_op_not -> None
+
+(** val run_typeof_value : state -> value -> char list **)
+
+let run_typeof_value s = function
+| Coq_value_prim w -> typeof_prim w
+| Coq_value_object l ->
+  if is_callable_dec s (Coq_value_object l)
+  then "function"
+  else "object"
+
+(** val run_unary_op :
+    runs_type -> state -> execution_ctx -> unary_op -> expr -> result **)
+
+let run_unary_op runs0 s c op e =
+  if prepost_unary_op_dec op
+  then if_success (runs0.runs_type_expr s c e) (fun s1 rv1 ->
+         if_spec (ref_get_value runs0 s1 c rv1) (fun s2 v2 ->
+           if_number (to_number runs0 s2 c v2) (fun s3 n1 ->
+             if_some (run_prepost_op op) (fun po ->
+               let (number_op, is_pre) = po in
+               let_binding (number_op n1) (fun n2 ->
+                 let_binding (Coq_prim_number (if is_pre then n2 else n1))
+                   (fun v ->
+                   if_void
+                     (ref_put_value runs0 s3 c rv1 (Coq_value_prim
+                       (Coq_prim_number n2))) (fun s4 ->
+                     result_out (Coq_out_ter (s4,
+                       (res_val (Coq_value_prim v)))))))))))
+  else (match op with
+        | Coq_unary_op_delete ->
+          if_success (runs0.runs_type_expr s c e) (fun s0 rv ->
+            match rv with
+            | Coq_resvalue_empty ->
+              res_ter s0 (res_val (Coq_value_prim (Coq_prim_bool true)))
+            | Coq_resvalue_value v ->
+              res_ter s0 (res_val (Coq_value_prim (Coq_prim_bool true)))
+            | Coq_resvalue_ref r ->
+              if ref_kind_comparable (ref_kind_of r) Coq_ref_kind_undef
+              then if r.ref_strict
+                   then run_error s0 Coq_native_error_syntax
+                   else res_ter s0
+                          (res_val (Coq_value_prim (Coq_prim_bool true)))
+              else (match r.ref_base with
+                    | Coq_ref_base_type_value v ->
+                      if_object (to_object s0 v) (fun s1 l ->
+                        runs0.runs_type_object_delete s1 c l r.ref_name
+                          r.ref_strict)
+                    | Coq_ref_base_type_env_loc l ->
+                      if r.ref_strict
+                      then run_error s0 Coq_native_error_syntax
+                      else env_record_delete_binding runs0 s0 c l r.ref_name))
+        | Coq_unary_op_void ->
+          if_spec (run_expr_get_value runs0 s c e) (fun s1 v ->
+            match op with
+            | Coq_unary_op_delete ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_void ->
+              res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+            | Coq_unary_op_typeof ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_add -> to_number runs0 s1 c v
+            | Coq_unary_op_neg ->
+              if_number (to_number runs0 s1 c v) (fun s2 n ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (JsNumber.neg n)))))
+            | Coq_unary_op_bitwise_not ->
+              if_spec (to_int32 runs0 s1 c v) (fun s2 k ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (of_int (int32_bitwise_not k))))))
+            | Coq_unary_op_not ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_bool
+                  (neg (convert_value_to_boolean v))))))
+        | Coq_unary_op_typeof ->
+          if_success (runs0.runs_type_expr s c e) (fun s1 rv ->
+            match rv with
+            | Coq_resvalue_empty ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Empty result for a `typeof\' in [run_unary_op].")
+            | Coq_resvalue_value v ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_string
+                  (run_typeof_value s1 v))))
+            | Coq_resvalue_ref r ->
+              if ref_kind_comparable (ref_kind_of r) Coq_ref_kind_undef
+              then res_ter s1
+                     (res_val (Coq_value_prim (Coq_prim_string
+                       ("undefined"))))
+              else if_spec (ref_get_value runs0 s1 c (Coq_resvalue_ref r))
+                     (fun s2 v ->
+                     res_ter s2
+                       (res_val (Coq_value_prim (Coq_prim_string
+                         (run_typeof_value s2 v))))))
+        | Coq_unary_op_post_incr ->
+          if_spec (run_expr_get_value runs0 s c e) (fun s1 v ->
+            match op with
+            | Coq_unary_op_delete ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_void ->
+              res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+            | Coq_unary_op_typeof ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_add -> to_number runs0 s1 c v
+            | Coq_unary_op_neg ->
+              if_number (to_number runs0 s1 c v) (fun s2 n ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (JsNumber.neg n)))))
+            | Coq_unary_op_bitwise_not ->
+              if_spec (to_int32 runs0 s1 c v) (fun s2 k ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (of_int (int32_bitwise_not k))))))
+            | Coq_unary_op_not ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_bool
+                  (neg (convert_value_to_boolean v))))))
+        | Coq_unary_op_post_decr ->
+          if_spec (run_expr_get_value runs0 s c e) (fun s1 v ->
+            match op with
+            | Coq_unary_op_delete ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_void ->
+              res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+            | Coq_unary_op_typeof ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_add -> to_number runs0 s1 c v
+            | Coq_unary_op_neg ->
+              if_number (to_number runs0 s1 c v) (fun s2 n ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (JsNumber.neg n)))))
+            | Coq_unary_op_bitwise_not ->
+              if_spec (to_int32 runs0 s1 c v) (fun s2 k ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (of_int (int32_bitwise_not k))))))
+            | Coq_unary_op_not ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_bool
+                  (neg (convert_value_to_boolean v))))))
+        | Coq_unary_op_pre_incr ->
+          if_spec (run_expr_get_value runs0 s c e) (fun s1 v ->
+            match op with
+            | Coq_unary_op_delete ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_void ->
+              res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+            | Coq_unary_op_typeof ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_add -> to_number runs0 s1 c v
+            | Coq_unary_op_neg ->
+              if_number (to_number runs0 s1 c v) (fun s2 n ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (JsNumber.neg n)))))
+            | Coq_unary_op_bitwise_not ->
+              if_spec (to_int32 runs0 s1 c v) (fun s2 k ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (of_int (int32_bitwise_not k))))))
+            | Coq_unary_op_not ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_bool
+                  (neg (convert_value_to_boolean v))))))
+        | Coq_unary_op_pre_decr ->
+          if_spec (run_expr_get_value runs0 s c e) (fun s1 v ->
+            match op with
+            | Coq_unary_op_delete ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_void ->
+              res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+            | Coq_unary_op_typeof ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_add -> to_number runs0 s1 c v
+            | Coq_unary_op_neg ->
+              if_number (to_number runs0 s1 c v) (fun s2 n ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (JsNumber.neg n)))))
+            | Coq_unary_op_bitwise_not ->
+              if_spec (to_int32 runs0 s1 c v) (fun s2 k ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (of_int (int32_bitwise_not k))))))
+            | Coq_unary_op_not ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_bool
+                  (neg (convert_value_to_boolean v))))))
+        | Coq_unary_op_add ->
+          if_spec (run_expr_get_value runs0 s c e) (fun s1 v ->
+            match op with
+            | Coq_unary_op_delete ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_void ->
+              res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+            | Coq_unary_op_typeof ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_add -> to_number runs0 s1 c v
+            | Coq_unary_op_neg ->
+              if_number (to_number runs0 s1 c v) (fun s2 n ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (JsNumber.neg n)))))
+            | Coq_unary_op_bitwise_not ->
+              if_spec (to_int32 runs0 s1 c v) (fun s2 k ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (of_int (int32_bitwise_not k))))))
+            | Coq_unary_op_not ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_bool
+                  (neg (convert_value_to_boolean v))))))
+        | Coq_unary_op_neg ->
+          if_spec (run_expr_get_value runs0 s c e) (fun s1 v ->
+            match op with
+            | Coq_unary_op_delete ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_void ->
+              res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+            | Coq_unary_op_typeof ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_add -> to_number runs0 s1 c v
+            | Coq_unary_op_neg ->
+              if_number (to_number runs0 s1 c v) (fun s2 n ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (JsNumber.neg n)))))
+            | Coq_unary_op_bitwise_not ->
+              if_spec (to_int32 runs0 s1 c v) (fun s2 k ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (of_int (int32_bitwise_not k))))))
+            | Coq_unary_op_not ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_bool
+                  (neg (convert_value_to_boolean v))))))
+        | Coq_unary_op_bitwise_not ->
+          if_spec (run_expr_get_value runs0 s c e) (fun s1 v ->
+            match op with
+            | Coq_unary_op_delete ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_void ->
+              res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+            | Coq_unary_op_typeof ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_add -> to_number runs0 s1 c v
+            | Coq_unary_op_neg ->
+              if_number (to_number runs0 s1 c v) (fun s2 n ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (JsNumber.neg n)))))
+            | Coq_unary_op_bitwise_not ->
+              if_spec (to_int32 runs0 s1 c v) (fun s2 k ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (of_int (int32_bitwise_not k))))))
+            | Coq_unary_op_not ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_bool
+                  (neg (convert_value_to_boolean v))))))
+        | Coq_unary_op_not ->
+          if_spec (run_expr_get_value runs0 s c e) (fun s1 v ->
+            match op with
+            | Coq_unary_op_delete ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_void ->
+              res_ter s1 (res_val (Coq_value_prim Coq_prim_undef))
+            | Coq_unary_op_typeof ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_post_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_incr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_pre_decr ->
+              (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                s1
+                ("Undealt regular operator in [run_unary_op].")
+            | Coq_unary_op_add -> to_number runs0 s1 c v
+            | Coq_unary_op_neg ->
+              if_number (to_number runs0 s1 c v) (fun s2 n ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (JsNumber.neg n)))))
+            | Coq_unary_op_bitwise_not ->
+              if_spec (to_int32 runs0 s1 c v) (fun s2 k ->
+                res_ter s2
+                  (res_val (Coq_value_prim (Coq_prim_number
+                    (of_int (int32_bitwise_not k))))))
+            | Coq_unary_op_not ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_bool
+                  (neg (convert_value_to_boolean v)))))))
+
+(** val create_new_function_in :
+    runs_type -> state -> execution_ctx -> char list list -> funcbody ->
+    result **)
+
+let create_new_function_in runs0 s c args bd =
+  creating_function_object runs0 s c args bd c.execution_ctx_lexical_env
+    c.execution_ctx_strict
+
+(** val init_object :
+    runs_type -> state -> execution_ctx -> object_loc -> propdefs -> result **)
+
+let rec init_object runs0 s c l = function
+| [] -> result_out (Coq_out_ter (s, (res_val (Coq_value_object l))))
+| p :: pds' ->
+  let (pn, pb) = p in
+  let_binding (string_of_propname pn) (fun x ->
+    let_binding (fun s1 desc ->
+      if_success (object_define_own_prop runs0 s1 c l x desc false)
+        (fun s2 rv -> init_object runs0 s2 c l pds')) (fun follows ->
+      match pb with
+      | Coq_propbody_val e0 ->
+        if_spec (run_expr_get_value runs0 s c e0) (fun s1 v0 ->
+          let desc = { descriptor_value = (Some v0); descriptor_writable =
+            (Some true); descriptor_get = None; descriptor_set = None;
+            descriptor_enumerable = (Some true); descriptor_configurable =
+            (Some true) }
+          in
+          follows s1 desc)
+      | Coq_propbody_get bd ->
+        if_value (create_new_function_in runs0 s c [] bd) (fun s1 v0 ->
+          let desc = { descriptor_value = None; descriptor_writable = None;
+            descriptor_get = (Some v0); descriptor_set = None;
+            descriptor_enumerable = (Some true); descriptor_configurable =
+            (Some true) }
+          in
+          follows s1 desc)
+      | Coq_propbody_set (args, bd) ->
+        if_value (create_new_function_in runs0 s c args bd) (fun s1 v0 ->
+          let desc = { descriptor_value = None; descriptor_writable = None;
+            descriptor_get = None; descriptor_set = (Some v0);
+            descriptor_enumerable = (Some true); descriptor_configurable =
+            (Some true) }
+          in
+          follows s1 desc)))
+
+(** val run_array_element_list :
+    runs_type -> state -> execution_ctx -> object_loc -> expr option list ->
+    float -> result **)
+
+let run_array_element_list runs0 s c l oes n =
+  match oes with
+  | [] -> result_out (Coq_out_ter (s, (res_val (Coq_value_object l))))
+  | o :: oes' ->
+    (match o with
+     | Some e ->
+       let_binding (fun s0 ->
+         runs0.runs_type_array_element_list s0 c l oes' 0.)
+         (fun loop_result ->
+         if_spec (run_expr_get_value runs0 s c e) (fun s0 v ->
+           if_value
+             (run_object_get runs0 s0 c l
+               ("length")) (fun s1 vlen ->
+             if_spec (to_uint32 runs0 s1 c vlen) (fun s2 ilen ->
+               if_string
+                 (to_string runs0 s2 c (Coq_value_prim (Coq_prim_number
+                   (of_int (Z.add ilen n))))) (fun s3 slen ->
+                 let_binding { attributes_data_value = v;
+                   attributes_data_writable = true;
+                   attributes_data_enumerable = true;
+                   attributes_data_configurable = true } (fun desc ->
+                   if_bool
+                     (object_define_own_prop runs0 s3 c l slen
+                       (descriptor_of_attributes (Coq_attributes_data_of
+                         desc)) false) (fun s4 x ->
+                     if_object (loop_result s4) (fun s5 l0 ->
+                       res_ter s5 (res_val (Coq_value_object l0))))))))))
+     | None ->
+       let_binding (elision_head_count (None :: oes')) (fun firstIndex ->
+         runs0.runs_type_array_element_list s c l
+           (elision_head_remove (None :: oes')) (my_Z_of_nat firstIndex)))
+
+(** val init_array :
+    runs_type -> state -> execution_ctx -> object_loc -> expr option list ->
+    result **)
+
+let init_array runs0 s c l oes =
+  let_binding (elision_tail_remove oes) (fun elementList ->
+    let_binding (elision_tail_count oes) (fun elisionLength ->
+      if_object (run_array_element_list runs0 s c l elementList 0.)
+        (fun s0 l0 ->
+        if_value
+          (run_object_get runs0 s0 c l0
+            ("length")) (fun s1 vlen ->
+          if_spec (to_uint32 runs0 s1 c vlen) (fun s2 ilen ->
+            if_spec
+              (to_uint32 runs0 s2 c (Coq_value_prim (Coq_prim_number
+                (of_int (Z.add ilen (my_Z_of_nat elisionLength))))))
+              (fun s3 len ->
+              if_not_throw
+                (object_put runs0 s3 c l0
+                  ("length")
+                  (Coq_value_prim (Coq_prim_number (of_int len)))
+                  throw_false) (fun s4 x ->
+                result_out (Coq_out_ter (s4,
+                  (res_val (Coq_value_object l0)))))))))))
+
+(** val run_var_decl_item :
+    runs_type -> state -> execution_ctx -> prop_name -> expr option -> result **)
+
+let run_var_decl_item runs0 s c x = function
+| Some e ->
+  if_spec (identifier_resolution runs0 s c x) (fun s1 ir ->
+    if_spec (run_expr_get_value runs0 s1 c e) (fun s2 v ->
+      if_void (ref_put_value runs0 s2 c (Coq_resvalue_ref ir) v) (fun s3 ->
+        result_out (Coq_out_ter (s3,
+          (res_val (Coq_value_prim (Coq_prim_string x))))))))
+| None ->
+  result_out (Coq_out_ter (s,
+    (res_val (Coq_value_prim (Coq_prim_string x)))))
+
+(** val run_var_decl :
+    runs_type -> state -> execution_ctx -> (prop_name * expr option) list ->
+    result **)
+
+let rec run_var_decl runs0 s c = function
+| [] -> result_out (Coq_out_ter (s, res_empty))
+| y :: xeos' ->
+  let (x, eo) = y in
+  if_value (run_var_decl_item runs0 s c x eo) (fun s1 vname ->
+    run_var_decl runs0 s1 c xeos')
+
+(** val run_list_expr :
+    runs_type -> state -> execution_ctx -> value list -> expr list -> value
+    list specres **)
+
+let rec run_list_expr runs0 s1 c vs = function
+| [] -> res_spec s1 (rev vs)
+| e :: es' ->
+  if_spec (run_expr_get_value runs0 s1 c e) (fun s2 v ->
+    run_list_expr runs0 s2 c (v :: vs) es')
+
+(** val run_block :
+    runs_type -> state -> execution_ctx -> stat list -> result **)
+
+let rec run_block runs0 s c = function
+| [] -> res_ter s (res_normal Coq_resvalue_empty)
+| t :: ts_rev' ->
+  if_success (run_block runs0 s c ts_rev') (fun s0 rv0 ->
+    if_success_state rv0 (runs0.runs_type_stat s0 c t) (fun x x0 ->
+      result_out (Coq_out_ter (x, (res_normal x0)))))
+
+(** val run_expr_binary_op :
+    runs_type -> state -> execution_ctx -> binary_op -> expr -> expr ->
+    result **)
+
+let run_expr_binary_op runs0 s c op e1 e2 =
+  match is_lazy_op op with
+  | Some b_ret ->
+    if_spec (run_expr_get_value runs0 s c e1) (fun s1 v1 ->
+      let_binding (convert_value_to_boolean v1) (fun b1 ->
+        if bool_comparable b1 b_ret
+        then res_ter s1 (res_val v1)
+        else if_spec (run_expr_get_value runs0 s1 c e2) (fun s2 v ->
+               res_ter s2 (res_val v))))
+  | None ->
+    if_spec (run_expr_get_value runs0 s c e1) (fun s1 v1 ->
+      if_spec (run_expr_get_value runs0 s1 c e2) (fun s2 v2 ->
+        run_binary_op runs0 s2 c op v1 v2))
+
+(** val run_expr_access :
+    runs_type -> state -> execution_ctx -> expr -> expr -> result **)
+
+let run_expr_access runs0 s c e1 e2 =
+  if_spec (run_expr_get_value runs0 s c e1) (fun s1 v1 ->
+    if_spec (run_expr_get_value runs0 s1 c e2) (fun s2 v2 ->
+      if or_decidable (value_comparable v1 (Coq_value_prim Coq_prim_undef))
+           (value_comparable v1 (Coq_value_prim Coq_prim_null))
+      then run_error s2 Coq_native_error_type
+      else if_string (to_string runs0 s2 c v2) (fun s3 x ->
+             res_ter s3
+               (res_ref (ref_create_value v1 x c.execution_ctx_strict)))))
+
+(** val run_expr_assign :
+    runs_type -> state -> execution_ctx -> binary_op option -> expr -> expr
+    -> result **)
+
+let run_expr_assign runs0 s c opo e1 e2 =
+  if_success (runs0.runs_type_expr s c e1) (fun s1 rv1 ->
+    let_binding (fun s0 rv' ->
+      match rv' with
+      | Coq_resvalue_empty ->
+        (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+          s0
+          ("Non-value result in [run_expr_assign].")
+      | Coq_resvalue_value v ->
+        if_void (ref_put_value runs0 s0 c rv1 v) (fun s' ->
+          result_out (Coq_out_ter (s', (res_val v))))
+      | Coq_resvalue_ref r ->
+        (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+          s0
+          ("Non-value result in [run_expr_assign]."))
+      (fun follow ->
+      match opo with
+      | Some op ->
+        if_spec (ref_get_value runs0 s1 c rv1) (fun s2 v1 ->
+          if_spec (run_expr_get_value runs0 s2 c e2) (fun s3 v2 ->
+            if_success (run_binary_op runs0 s3 c op v1 v2) follow))
+      | None ->
+        if_spec (run_expr_get_value runs0 s1 c e2) (fun x x0 ->
+          follow x (Coq_resvalue_value x0))))
+
+(** val run_expr_function :
+    runs_type -> state -> execution_ctx -> prop_name option -> char list list
+    -> funcbody -> result **)
+
+let run_expr_function runs0 s c fo args bd =
+  match fo with
+  | Some fn ->
+    let_binding (lexical_env_alloc_decl s c.execution_ctx_lexical_env)
+      (fun p ->
+      let (lex', s') = p in
+      let follow = fun l ->
+        if_some (env_record_binds_pickable_option s' l) (fun e ->
+          if_void (env_record_create_immutable_binding s' l fn) (fun s1 ->
+            if_object
+              (creating_function_object runs0 s1 c args bd lex'
+                (funcbody_is_strict bd)) (fun s2 l0 ->
+              if_void
+                (env_record_initialize_immutable_binding s2 l fn
+                  (Coq_value_object l0)) (fun s3 ->
+                result_out (Coq_out_ter (s3,
+                  (res_val (Coq_value_object l0))))))))
+      in
+      destr_list lex' (fun x ->
+        (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+          s'
+          ("Empty lexical environnment allocated in [run_expr_function]."))
+        (fun l x -> follow l) ())
+  | None ->
+    let lex = c.execution_ctx_lexical_env in
+    creating_function_object runs0 s c args bd lex (funcbody_is_strict bd)
+
+(** val entering_eval_code :
+    runs_type -> state -> execution_ctx -> bool -> funcbody -> (state ->
+    execution_ctx -> result) -> result **)
+
+let entering_eval_code runs0 s c direct bd k =
+  let_binding
+    (coq_or (funcbody_is_strict bd) ((&&) direct c.execution_ctx_strict))
+    (fun str ->
+    let_binding (if direct then c else execution_ctx_initial str) (fun c' ->
+      let_binding
+        (if str
+         then lexical_env_alloc_decl s c'.execution_ctx_lexical_env
+         else (c'.execution_ctx_lexical_env, s)) (fun p ->
+        let (lex, s') = p in
+        let_binding (if str then execution_ctx_with_lex_same c' lex else c')
+          (fun c1 ->
+          let_binding (funcbody_prog bd) (fun p0 ->
+            if_void
+              (execution_ctx_binding_inst runs0 s' c1 Coq_codetype_eval None
+                p0 []) (fun s1 -> k s1 c1))))))
+
+(** val run_eval :
+    runs_type -> state -> execution_ctx -> bool -> value list -> result **)
+
+let run_eval runs0 s c is_direct_call vs =
+  match get_arg 0 vs with
+  | Coq_value_prim p ->
+    (match p with
+     | Coq_prim_undef ->
+       result_out (Coq_out_ter (s,
+         (res_val (Coq_value_prim Coq_prim_undef))))
+     | Coq_prim_null ->
+       result_out (Coq_out_ter (s, (res_val (Coq_value_prim Coq_prim_null))))
+     | Coq_prim_bool b ->
+       result_out (Coq_out_ter (s,
+         (res_val (Coq_value_prim (Coq_prim_bool b)))))
+     | Coq_prim_number n ->
+       result_out (Coq_out_ter (s,
+         (res_val (Coq_value_prim (Coq_prim_number n)))))
+     | Coq_prim_string s0 ->
+       let_binding (coq_and is_direct_call c.execution_ctx_strict)
+         (fun str ->
+         match parse_pickable s0 str with
+         | Some p0 ->
+           entering_eval_code runs0 s c is_direct_call (Coq_funcbody_intro
+             (p0, s0)) (fun s1 c' ->
+             if_ter (runs0.runs_type_prog s1 c' p0) (fun s2 r ->
+               match r.res_type with
+               | Coq_restype_normal ->
+                 if_empty_label s2 r (fun x ->
+                   match r.res_value with
+                   | Coq_resvalue_empty ->
+                     res_ter s2 (res_val (Coq_value_prim Coq_prim_undef))
+                   | Coq_resvalue_value v -> res_ter s2 (res_val v)
+                   | Coq_resvalue_ref r0 ->
+                     (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                       s2
+                       ("Reference found in the result of an `eval\' in [run_eval]."))
+               | Coq_restype_break ->
+                 (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                   s2
+                   ("Forbidden result type returned by an `eval\' in [run_eval].")
+               | Coq_restype_continue ->
+                 (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                   s2
+                   ("Forbidden result type returned by an `eval\' in [run_eval].")
+               | Coq_restype_return ->
+                 (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                   s2
+                   ("Forbidden result type returned by an `eval\' in [run_eval].")
+               | Coq_restype_throw -> res_ter s2 (res_throw r.res_value)))
+         | None -> run_error s Coq_native_error_syntax))
+  | Coq_value_object o ->
+    result_out (Coq_out_ter (s, (res_val (Coq_value_object o))))
+
+(** val run_expr_call :
+    runs_type -> state -> execution_ctx -> expr -> expr list -> result **)
+
+let run_expr_call runs0 s c e1 e2s =
+  let_binding (is_syntactic_eval e1) (fun is_eval_direct ->
+    if_success (runs0.runs_type_expr s c e1) (fun s1 rv ->
+      if_spec (ref_get_value runs0 s1 c rv) (fun s2 f ->
+        if_spec (run_list_expr runs0 s2 c [] e2s) (fun s3 vs ->
+          match f with
+          | Coq_value_prim p -> run_error s3 Coq_native_error_type
+          | Coq_value_object l ->
+            if is_callable_dec s3 (Coq_value_object l)
+            then let_binding (fun vthis ->
+                   if object_loc_comparable l (Coq_object_loc_prealloc
+                        Coq_prealloc_global_eval)
+                   then run_eval runs0 s3 c is_eval_direct vs
+                   else runs0.runs_type_call s3 c l vthis vs) (fun follow ->
+                   match rv with
+                   | Coq_resvalue_empty ->
+                     (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                       s3
+                       ("[run_expr_call] unable to call an  empty result.")
+                   | Coq_resvalue_value v ->
+                     follow (Coq_value_prim Coq_prim_undef)
+                   | Coq_resvalue_ref r ->
+                     (match r.ref_base with
+                      | Coq_ref_base_type_value v ->
+                        if or_decidable
+                             (ref_kind_comparable (ref_kind_of r)
+                               Coq_ref_kind_primitive_base)
+                             (or_decidable
+                               (ref_kind_comparable (ref_kind_of r)
+                                 Coq_ref_kind_null)
+                               (ref_kind_comparable (ref_kind_of r)
+                                 Coq_ref_kind_object))
+                        then follow v
+                        else (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                               s3
+                               ("[run_expr_call] unable to call a non-property function.")
+                      | Coq_ref_base_type_env_loc l0 ->
+                        if_some (env_record_implicit_this_value s3 l0) follow))
+            else run_error s3 Coq_native_error_type))))
+
+(** val run_expr_conditionnal :
+    runs_type -> state -> execution_ctx -> expr -> expr -> expr -> result **)
+
+let run_expr_conditionnal runs0 s c e1 e2 e3 =
+  if_spec (run_expr_get_value runs0 s c e1) (fun s1 v1 ->
+    let_binding (convert_value_to_boolean v1) (fun b ->
+      let_binding (if b then e2 else e3) (fun e ->
+        if_spec (run_expr_get_value runs0 s1 c e) (fun s0 r ->
+          res_ter s0 (res_val r)))))
+
+(** val run_expr_new :
+    runs_type -> state -> execution_ctx -> expr -> expr list -> result **)
+
+let run_expr_new runs0 s c e1 e2s =
+  if_spec (run_expr_get_value runs0 s c e1) (fun s1 v ->
+    if_spec (run_list_expr runs0 s1 c [] e2s) (fun s2 args ->
+      match v with
+      | Coq_value_prim p -> run_error s2 Coq_native_error_type
+      | Coq_value_object l ->
+        if_some (run_object_method object_construct_ s2 l) (fun coo ->
+          match coo with
+          | Some co -> run_construct runs0 s2 c co l args
+          | None -> run_error s2 Coq_native_error_type)))
+
+(** val run_stat_label :
+    runs_type -> state -> execution_ctx -> label -> stat -> result **)
+
+let run_stat_label runs0 s c lab t =
+  if_break (runs0.runs_type_stat s c t) (fun s1 r1 ->
+    result_out (Coq_out_ter (s1,
+      (if label_comparable r1.res_label lab
+       then res_normal r1.res_value
+       else r1))))
+
+(** val run_stat_with :
+    runs_type -> state -> execution_ctx -> expr -> stat -> result **)
+
+let run_stat_with runs0 s c e1 t2 =
+  if_spec (run_expr_get_value runs0 s c e1) (fun s1 v1 ->
+    if_object (to_object s1 v1) (fun s2 l ->
+      let_binding c.execution_ctx_lexical_env (fun lex ->
+        let_binding (lexical_env_alloc_object s2 lex l provide_this_true)
+          (fun p ->
+          let (lex', s3) = p in
+          let_binding (execution_ctx_with_lex c lex') (fun c' ->
+            runs0.runs_type_stat s3 c' t2)))))
+
+(** val run_stat_if :
+    runs_type -> state -> execution_ctx -> expr -> stat -> stat option ->
+    result **)
+
+let run_stat_if runs0 s c e1 t2 to0 =
+  if_spec (run_expr_get_value runs0 s c e1) (fun s1 v1 ->
+    let_binding (convert_value_to_boolean v1) (fun b ->
+      if b
+      then runs0.runs_type_stat s1 c t2
+      else (match to0 with
+            | Some t3 -> runs0.runs_type_stat s1 c t3
+            | None ->
+              result_out (Coq_out_ter (s1, (res_normal Coq_resvalue_empty))))))
+
+(** val run_stat_while :
+    runs_type -> state -> execution_ctx -> resvalue -> label_set -> expr ->
+    stat -> result **)
+
+let run_stat_while runs0 s c rv labs e1 t2 =
+  if_spec (run_expr_get_value runs0 s c e1) (fun s1 v1 ->
+    let_binding (convert_value_to_boolean v1) (fun b ->
+      if b
+      then if_ter (runs0.runs_type_stat s1 c t2) (fun s2 r ->
+             let_binding
+               (if not_decidable
+                     (resvalue_comparable r.res_value Coq_resvalue_empty)
+                then r.res_value
+                else rv) (fun rv' ->
+               let_binding (fun x ->
+                 runs0.runs_type_stat_while s2 c rv' labs e1 t2) (fun loop ->
+                 if or_decidable
+                      (not_decidable
+                        (restype_comparable r.res_type Coq_restype_continue))
+                      (not_decidable (bool_decidable (res_label_in r labs)))
+                 then if and_decidable
+                           (restype_comparable r.res_type Coq_restype_break)
+                           (bool_decidable (res_label_in r labs))
+                      then res_ter s2 (res_normal rv')
+                      else if not_decidable
+                                (restype_comparable r.res_type
+                                  Coq_restype_normal)
+                           then res_ter s2 r
+                           else loop ()
+                 else loop ())))
+      else res_ter s1 (res_normal rv)))
+
+(** val run_stat_switch_end :
+    runs_type -> state -> execution_ctx -> resvalue -> switchclause list ->
+    result **)
+
+let rec run_stat_switch_end runs0 s c rv = function
+| [] -> result_out (Coq_out_ter (s, (res_normal rv)))
+| y :: scs' ->
+  let Coq_switchclause_intro (e, ts) = y in
+  if_success_state rv (run_block runs0 s c (rev ts)) (fun s1 rv1 ->
+    run_stat_switch_end runs0 s1 c rv1 scs')
+
+(** val run_stat_switch_no_default :
+    runs_type -> state -> execution_ctx -> value -> resvalue -> switchclause
+    list -> result **)
+
+let rec run_stat_switch_no_default runs0 s c vi rv = function
+| [] -> result_out (Coq_out_ter (s, (res_normal rv)))
+| y :: scs' ->
+  let Coq_switchclause_intro (e, ts) = y in
+  if_spec (run_expr_get_value runs0 s c e) (fun s1 v1 ->
+    let_binding (strict_equality_test v1 vi) (fun b ->
+      if b
+      then if_success (run_block runs0 s1 c (rev ts)) (fun s2 rv2 ->
+             run_stat_switch_end runs0 s2 c rv2 scs')
+      else run_stat_switch_no_default runs0 s1 c vi rv scs'))
+
+(** val run_stat_switch_with_default_default :
+    runs_type -> state -> execution_ctx -> stat list -> switchclause list ->
+    result **)
+
+let run_stat_switch_with_default_default runs0 s c ts scs =
+  if_success (run_block runs0 s c (rev ts)) (fun s1 rv ->
+    run_stat_switch_end runs0 s1 c rv scs)
+
+(** val run_stat_switch_with_default_B :
+    runs_type -> state -> execution_ctx -> value -> resvalue -> stat list ->
+    switchclause list -> result **)
+
+let rec run_stat_switch_with_default_B runs0 s c vi rv ts0 scs = match scs with
+| [] -> run_stat_switch_with_default_default runs0 s c ts0 scs
+| y :: scs' ->
+  let Coq_switchclause_intro (e, ts) = y in
+  if_spec (run_expr_get_value runs0 s c e) (fun s1 v1 ->
+    let_binding (strict_equality_test v1 vi) (fun b ->
+      if b
+      then if_success (run_block runs0 s1 c (rev ts)) (fun s2 rv2 ->
+             run_stat_switch_end runs0 s2 c rv2 scs')
+      else run_stat_switch_with_default_B runs0 s1 c vi rv ts0 scs'))
+
+(** val run_stat_switch_with_default_A :
+    runs_type -> state -> execution_ctx -> bool -> value -> resvalue ->
+    switchclause list -> stat list -> switchclause list -> result **)
+
+let rec run_stat_switch_with_default_A runs0 s c found vi rv scs1 ts0 scs2 =
+  match scs1 with
+  | [] ->
+    if found
+    then run_stat_switch_with_default_default runs0 s c ts0 scs2
+    else run_stat_switch_with_default_B runs0 s c vi rv ts0 scs2
+  | y :: scs' ->
+    let Coq_switchclause_intro (e, ts) = y in
+    let_binding (fun s0 ->
+      if_success_state rv (run_block runs0 s0 c (rev ts)) (fun s1 rv0 ->
+        run_stat_switch_with_default_A runs0 s1 c true vi rv0 scs' ts0 scs2))
+      (fun follow ->
+      if found
+      then follow s
+      else if_spec (run_expr_get_value runs0 s c e) (fun s1 v1 ->
+             let_binding (strict_equality_test v1 vi) (fun b ->
+               if b
+               then follow s1
+               else run_stat_switch_with_default_A runs0 s1 c false vi rv
+                      scs' ts0 scs2)))
+
+(** val run_stat_switch :
+    runs_type -> state -> execution_ctx -> label_set -> expr -> switchbody ->
+    result **)
+
+let run_stat_switch runs0 s c labs e sb =
+  if_spec (run_expr_get_value runs0 s c e) (fun s1 vi ->
+    let_binding (fun w ->
+      if_success
+        (if_break w (fun s2 r ->
+          if res_label_in r labs
+          then result_out (Coq_out_ter (s2, (res_normal r.res_value)))
+          else result_out (Coq_out_ter (s2, r)))) (fun s0 r ->
+        res_ter s0 (res_normal r))) (fun follow ->
+      match sb with
+      | Coq_switchbody_nodefault scs ->
+        follow
+          (run_stat_switch_no_default runs0 s1 c vi Coq_resvalue_empty scs)
+      | Coq_switchbody_withdefault (scs1, ts, scs2) ->
+        follow
+          (run_stat_switch_with_default_A runs0 s1 c false vi
+            Coq_resvalue_empty scs1 ts scs2)))
+
+(** val run_stat_do_while :
+    runs_type -> state -> execution_ctx -> resvalue -> label_set -> expr ->
+    stat -> result **)
+
+let run_stat_do_while runs0 s c rv labs e1 t2 =
+  if_ter (runs0.runs_type_stat s c t2) (fun s1 r ->
+    let_binding
+      (if resvalue_comparable r.res_value Coq_resvalue_empty
+       then rv
+       else r.res_value) (fun rv' ->
+      let_binding (fun x ->
+        if_spec (run_expr_get_value runs0 s1 c e1) (fun s2 v1 ->
+          let_binding (convert_value_to_boolean v1) (fun b ->
+            if b
+            then runs0.runs_type_stat_do_while s2 c rv' labs e1 t2
+            else res_ter s2 (res_normal rv')))) (fun loop ->
+        if and_decidable (restype_comparable r.res_type Coq_restype_continue)
+             (bool_decidable (res_label_in r labs))
+        then loop ()
+        else if and_decidable
+                  (restype_comparable r.res_type Coq_restype_break)
+                  (bool_decidable (res_label_in r labs))
+             then res_ter s1 (res_normal rv')
+             else if not_decidable
+                       (restype_comparable r.res_type Coq_restype_normal)
+                  then res_ter s1 r
+                  else loop ())))
+
+(** val run_stat_try :
+    runs_type -> state -> execution_ctx -> stat -> (prop_name * stat) option
+    -> stat option -> result **)
+
+let run_stat_try runs0 s c t1 t2o t3o =
+  let_binding (fun s1 r ->
+    match t3o with
+    | Some t3 ->
+      if_success (runs0.runs_type_stat s1 c t3) (fun s2 rv' -> res_ter s2 r)
+    | None -> res_ter s1 r) (fun finally ->
+    if_any_or_throw (runs0.runs_type_stat s c t1) finally (fun s1 v ->
+      match t2o with
+      | Some y ->
+        let (x, t2) = y in
+        let_binding c.execution_ctx_lexical_env (fun lex ->
+          let_binding (lexical_env_alloc_decl s1 lex) (fun p ->
+            let (lex', s') = p in
+            (match lex' with
+             | [] ->
+               (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                 s'
+                 ("Empty lexical environnment in [run_stat_try].")
+             | l :: oldlex ->
+               if_void
+                 (env_record_create_set_mutable_binding runs0 s' c l x None v
+                   throw_irrelevant) (fun s2 ->
+                 let c' = execution_ctx_with_lex c lex' in
+                 if_ter (runs0.runs_type_stat s2 c' t2) finally))))
+      | None -> finally s1 (res_throw (Coq_resvalue_value v))))
+
+(** val run_stat_throw :
+    runs_type -> state -> execution_ctx -> expr -> result **)
+
+let run_stat_throw runs0 s c e =
+  if_spec (run_expr_get_value runs0 s c e) (fun s1 v1 ->
+    res_ter s1 (res_throw (Coq_resvalue_value v1)))
+
+(** val run_stat_return :
+    runs_type -> state -> execution_ctx -> expr option -> result **)
+
+let run_stat_return runs0 s c = function
+| Some e ->
+  if_spec (run_expr_get_value runs0 s c e) (fun s1 v1 ->
+    res_ter s1 (res_return (Coq_resvalue_value v1)))
+| None ->
+  result_out (Coq_out_ter (s,
+    (res_return (Coq_resvalue_value (Coq_value_prim Coq_prim_undef)))))
+
+(** val run_stat_for_loop :
+    runs_type -> state -> execution_ctx -> label_set -> resvalue -> expr
+    option -> expr option -> stat -> result **)
+
+let run_stat_for_loop runs0 s c labs rv eo2 eo3 t =
+  let_binding (fun s0 ->
+    if_ter (runs0.runs_type_stat s0 c t) (fun s1 r ->
+      let_binding
+        (if not_decidable
+              (resvalue_comparable r.res_value Coq_resvalue_empty)
+         then r.res_value
+         else rv) (fun rv' ->
+        let_binding (fun s2 ->
+          runs0.runs_type_stat_for_loop s2 c labs rv' eo2 eo3 t) (fun loop ->
+          if and_decidable (restype_comparable r.res_type Coq_restype_break)
+               (bool_decidable (res_label_in r labs))
+          then res_ter s1 (res_normal rv')
+          else if or_decidable
+                    (restype_comparable r.res_type Coq_restype_normal)
+                    (and_decidable
+                      (restype_comparable r.res_type Coq_restype_continue)
+                      (bool_decidable (res_label_in r labs)))
+               then (match eo3 with
+                     | Some e3 ->
+                       if_spec (run_expr_get_value runs0 s1 c e3)
+                         (fun s2 v3 -> loop s2)
+                     | None -> loop s1)
+               else res_ter s1 r)))) (fun follows ->
+    match eo2 with
+    | Some e2 ->
+      if_spec (run_expr_get_value runs0 s c e2) (fun s0 v2 ->
+        let_binding (convert_value_to_boolean v2) (fun b ->
+          if b then follows s0 else res_ter s0 (res_normal rv)))
+    | None -> follows s)
+
+(** val run_stat_for :
+    runs_type -> state -> execution_ctx -> label_set -> expr option -> expr
+    option -> expr option -> stat -> result **)
+
+let run_stat_for runs0 s c labs eo1 eo2 eo3 t =
+  let follows = fun s0 ->
+    runs0.runs_type_stat_for_loop s0 c labs Coq_resvalue_empty eo2 eo3 t
+  in
+  (match eo1 with
+   | Some e1 ->
+     if_spec (run_expr_get_value runs0 s c e1) (fun s0 v1 -> follows s0)
+   | None -> follows s)
+
+(** val run_stat_for_var :
+    runs_type -> state -> execution_ctx -> label_set -> (char list * expr
+    option) list -> expr option -> expr option -> stat -> result **)
+
+let run_stat_for_var runs0 s c labs ds eo2 eo3 t =
+  if_ter (runs0.runs_type_stat s c (Coq_stat_var_decl ds)) (fun s0 r ->
+    runs0.runs_type_stat_for_loop s0 c labs Coq_resvalue_empty eo2 eo3 t)
+
+(** val run_expr : runs_type -> state -> execution_ctx -> expr -> result **)
+
+let run_expr runs0 s c = function
+| Coq_expr_this ->
+  result_out (Coq_out_ter (s, (res_val c.execution_ctx_this_binding)))
+| Coq_expr_identifier x ->
+  if_spec (identifier_resolution runs0 s c x) (fun s0 r ->
+    res_ter s0 (res_ref r))
+| Coq_expr_literal i ->
+  result_out (Coq_out_ter (s,
+    (res_val (Coq_value_prim (convert_literal_to_prim i)))))
+| Coq_expr_object pds ->
+  if_object (run_construct_prealloc runs0 s c Coq_prealloc_object [])
+    (fun s1 l -> init_object runs0 s1 c l pds)
+| Coq_expr_array oes ->
+  if_object (run_construct_prealloc runs0 s c Coq_prealloc_array [])
+    (fun s1 l -> init_array runs0 s1 c l oes)
+| Coq_expr_function (fo, args, bd) -> run_expr_function runs0 s c fo args bd
+| Coq_expr_access (e1, e2) -> run_expr_access runs0 s c e1 e2
+| Coq_expr_member (e1, f) ->
+  runs0.runs_type_expr s c (Coq_expr_access (e1, (Coq_expr_literal
+    (Coq_literal_string f))))
+| Coq_expr_new (e1, e2s) -> run_expr_new runs0 s c e1 e2s
+| Coq_expr_call (e1, e2s) -> run_expr_call runs0 s c e1 e2s
+| Coq_expr_unary_op (op, e0) -> run_unary_op runs0 s c op e0
+| Coq_expr_binary_op (e1, op, e2) -> run_expr_binary_op runs0 s c op e1 e2
+| Coq_expr_conditional (e1, e2, e3) ->
+  run_expr_conditionnal runs0 s c e1 e2 e3
+| Coq_expr_assign (e1, opo, e2) -> run_expr_assign runs0 s c opo e1 e2
+
+(** val run_stat : runs_type -> state -> execution_ctx -> stat -> result **)
+
+let run_stat runs0 s c = function
+| Coq_stat_expr e ->
+  if_spec (run_expr_get_value runs0 s c e) (fun s0 r ->
+    res_ter s0 (res_val r))
+| Coq_stat_label (lab, t0) ->
+  run_stat_label runs0 s c (Coq_label_string lab) t0
+| Coq_stat_block ts -> run_block runs0 s c (rev ts)
+| Coq_stat_var_decl xeos -> run_var_decl runs0 s c xeos
+| Coq_stat_if (e1, t2, to0) -> run_stat_if runs0 s c e1 t2 to0
+| Coq_stat_do_while (ls, t1, e2) ->
+  runs0.runs_type_stat_do_while s c Coq_resvalue_empty ls e2 t1
+| Coq_stat_while (ls, e1, t2) ->
+  runs0.runs_type_stat_while s c Coq_resvalue_empty ls e1 t2
+| Coq_stat_with (e1, t2) -> run_stat_with runs0 s c e1 t2
+| Coq_stat_throw e -> run_stat_throw runs0 s c e
+| Coq_stat_return eo -> run_stat_return runs0 s c eo
+| Coq_stat_break so -> result_out (Coq_out_ter (s, (res_break so)))
+| Coq_stat_continue so -> result_out (Coq_out_ter (s, (res_continue so)))
+| Coq_stat_try (t1, t2o, t3o) -> run_stat_try runs0 s c t1 t2o t3o
+| Coq_stat_for (ls, eo1, eo2, eo3, s0) ->
+  run_stat_for runs0 s c ls eo1 eo2 eo3 s0
+| Coq_stat_for_var (ls, ds, eo2, eo3, s0) ->
+  run_stat_for_var runs0 s c ls ds eo2 eo3 s0
+| Coq_stat_for_in (ls, e1, e2, s0) ->
+  (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+    ("stat_for_in")
+| Coq_stat_for_in_var (ls, x, e1o, e2, s0) ->
+  (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+    ("stat_for_in_var")
+| Coq_stat_debugger -> result_out (Coq_out_ter (s, res_empty))
+| Coq_stat_switch (labs, e, sb) -> run_stat_switch runs0 s c labs e sb
+
+(** val run_elements :
+    runs_type -> state -> execution_ctx -> elements -> result **)
+
+let rec run_elements runs0 s c = function
+| [] -> result_out (Coq_out_ter (s, (res_normal Coq_resvalue_empty)))
+| el :: els_rev' ->
+  if_success (run_elements runs0 s c els_rev') (fun s0 rv0 ->
+    match el with
+    | Coq_element_stat t ->
+      if_ter (runs0.runs_type_stat s0 c t) (fun s1 r1 ->
+        let r2 = res_overwrite_value_if_empty rv0 r1 in
+        res_out (Coq_out_ter (s1, r2)))
+    | Coq_element_func_decl (name, args, bd) -> res_ter s0 (res_normal rv0))
+
+(** val run_prog : runs_type -> state -> execution_ctx -> prog -> result **)
+
+let run_prog runs0 s c = function
+| Coq_prog_intro (str, els) -> run_elements runs0 s c (rev els)
+
+(** val push :
+    runs_type -> state -> execution_ctx -> object_loc -> value list -> float
+    -> result **)
+
+let rec push runs0 s c l args ilen =
+  let_binding (of_int ilen) (fun vlen ->
+    match args with
+    | [] ->
+      if_not_throw
+        (object_put runs0 s c l ("length")
+          (Coq_value_prim (Coq_prim_number vlen)) throw_true) (fun s0 x ->
+        result_out (Coq_out_ter (s0,
+          (res_val (Coq_value_prim (Coq_prim_number vlen))))))
+    | v :: vs ->
+      if_string (to_string runs0 s c (Coq_value_prim (Coq_prim_number vlen)))
+        (fun s0 slen ->
+        if_not_throw (object_put runs0 s0 c l slen v throw_true) (fun s1 x ->
+          push runs0 s1 c l vs (Z.add ilen 1.))))
+
+(** val run_object_is_sealed :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name list ->
+    result **)
+
+let rec run_object_is_sealed runs0 s c l = function
+| [] ->
+  if_some (run_object_method object_extensible_ s l) (fun ext ->
+    res_ter s (res_val (Coq_value_prim (Coq_prim_bool (neg ext)))))
+| x :: xs' ->
+  if_spec (runs0.runs_type_object_get_own_prop s c l x) (fun s0 d ->
+    match d with
+    | Coq_full_descriptor_undef ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s0
+        ("[run_object_is_sealed]:  Undefined descriptor found in a place where it shouldn\'t.")
+    | Coq_full_descriptor_some a ->
+      if attributes_configurable a
+      then res_ter s0 (res_val (Coq_value_prim (Coq_prim_bool false)))
+      else run_object_is_sealed runs0 s0 c l xs')
+
+(** val run_object_seal :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name list ->
+    result **)
+
+let rec run_object_seal runs0 s c l = function
+| [] ->
+  if_some (run_object_heap_set_extensible false s l) (fun s0 ->
+    res_ter s0 (res_val (Coq_value_object l)))
+| x :: xs' ->
+  if_spec (runs0.runs_type_object_get_own_prop s c l x) (fun s0 d ->
+    match d with
+    | Coq_full_descriptor_undef ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s0
+        ("[run_object_seal]:  Undefined descriptor found in a place where it shouldn\'t.")
+    | Coq_full_descriptor_some a ->
+      let a' =
+        if attributes_configurable a
+        then let desc = { descriptor_value = None; descriptor_writable =
+               None; descriptor_get = None; descriptor_set = None;
+               descriptor_enumerable = None; descriptor_configurable = (Some
+               false) }
+             in
+             attributes_update a desc
+        else a
+      in
+      if_bool
+        (object_define_own_prop runs0 s0 c l x (descriptor_of_attributes a')
+          true) (fun s1 x0 -> run_object_seal runs0 s1 c l xs'))
+
+(** val run_object_freeze :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name list ->
+    result **)
+
+let rec run_object_freeze runs0 s c l = function
+| [] ->
+  if_some (run_object_heap_set_extensible false s l) (fun s0 ->
+    res_ter s0 (res_val (Coq_value_object l)))
+| x :: xs' ->
+  if_spec (runs0.runs_type_object_get_own_prop s c l x) (fun s0 d ->
+    match d with
+    | Coq_full_descriptor_undef ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s0
+        ("[run_object_freeze]:  Undefined descriptor found in a place where it shouldn\'t.")
+    | Coq_full_descriptor_some a ->
+      let a' =
+        if and_decidable (attributes_is_data_dec a)
+             (bool_decidable (attributes_writable a))
+        then let desc = { descriptor_value = None; descriptor_writable =
+               (Some false); descriptor_get = None; descriptor_set = None;
+               descriptor_enumerable = None; descriptor_configurable = None }
+             in
+             attributes_update a desc
+        else a
+      in
+      let a'' =
+        if attributes_configurable a'
+        then let desc = { descriptor_value = None; descriptor_writable =
+               None; descriptor_get = None; descriptor_set = None;
+               descriptor_enumerable = None; descriptor_configurable = (Some
+               false) }
+             in
+             attributes_update a' desc
+        else a'
+      in
+      if_bool
+        (object_define_own_prop runs0 s0 c l x (descriptor_of_attributes a'')
+          true) (fun s1 x0 -> run_object_freeze runs0 s1 c l xs'))
+
+(** val run_object_is_frozen :
+    runs_type -> state -> execution_ctx -> object_loc -> prop_name list ->
+    result **)
+
+let rec run_object_is_frozen runs0 s c l = function
+| [] ->
+  if_some (run_object_method object_extensible_ s l) (fun ext ->
+    res_ter s (res_val (Coq_value_prim (Coq_prim_bool (neg ext)))))
+| x :: xs' ->
+  if_spec (runs0.runs_type_object_get_own_prop s c l x) (fun s0 d ->
+    let_binding (fun a ->
+      if attributes_configurable a
+      then res_ter s0 (res_val (Coq_value_prim (Coq_prim_bool false)))
+      else run_object_is_frozen runs0 s0 c l xs') (fun check_configurable ->
+      match d with
+      | Coq_full_descriptor_undef ->
+        (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+          s0
+          ("[run_object_is_frozen]:  Undefined descriptor found in a place where it shouldn\'t.")
+      | Coq_full_descriptor_some a ->
+        (match a with
+         | Coq_attributes_data_of ad ->
+           if attributes_writable (Coq_attributes_data_of ad)
+           then res_ter s0 (res_val (Coq_value_prim (Coq_prim_bool false)))
+           else check_configurable (Coq_attributes_data_of ad)
+         | Coq_attributes_accessor_of aa ->
+           check_configurable (Coq_attributes_accessor_of aa))))
+
+(** val run_get_args_for_apply :
+    runs_type -> state -> execution_ctx -> object_loc -> float -> float ->
+    value list specres **)
+
+let run_get_args_for_apply runs0 s c l index n =
+  if lt_int_decidable index n
+  then if_string
+         (to_string runs0 s c (Coq_value_prim (Coq_prim_number
+           (of_int index)))) (fun s0 sindex ->
+         if_value (run_object_get runs0 s0 c l sindex) (fun s1 v ->
+           let_binding
+             (runs0.runs_type_get_args_for_apply s1 c l (Z.add index 1.) n)
+             (fun tail_args ->
+             if_spec tail_args (fun s2 tail -> res_spec s2 (v :: tail)))))
+  else res_spec s []
+
+(** val valueToStringForJoin :
+    runs_type -> state -> execution_ctx -> object_loc -> float -> char list
+    specres **)
+
+let valueToStringForJoin runs0 s c l k =
+  if_string
+    (to_string runs0 s c (Coq_value_prim (Coq_prim_number (of_int k))))
+    (fun s0 prop ->
+    if_value (run_object_get runs0 s0 c l prop) (fun s1 v ->
+      match v with
+      | Coq_value_prim p ->
+        (match p with
+         | Coq_prim_undef -> res_spec s1 []
+         | Coq_prim_null -> res_spec s1 []
+         | Coq_prim_bool b ->
+           if_string (to_string runs0 s1 c v) (fun s2 s3 -> res_spec s2 s3)
+         | Coq_prim_number n ->
+           if_string (to_string runs0 s1 c v) (fun s2 s3 -> res_spec s2 s3)
+         | Coq_prim_string s2 ->
+           if_string (to_string runs0 s1 c v) (fun s3 s4 -> res_spec s3 s4))
+      | Coq_value_object o ->
+        if_string (to_string runs0 s1 c v) (fun s2 s3 -> res_spec s2 s3)))
+
+(** val run_array_join_elements :
+    runs_type -> state -> execution_ctx -> object_loc -> float -> float ->
+    char list -> char list -> result **)
+
+let run_array_join_elements runs0 s c l k length0 sep sR =
+  if lt_int_decidable k length0
+  then let_binding (append sR sep) (fun ss ->
+         let_binding (valueToStringForJoin runs0 s c l k) (fun sE ->
+           if_spec sE (fun s0 element ->
+             let_binding (append ss element) (fun sR0 ->
+               runs0.runs_type_array_join_elements s0 c l (Z.add k 1.)
+                 length0 sep sR0))))
+  else res_ter s (res_val (Coq_value_prim (Coq_prim_string sR)))
+
+(** val run_call_prealloc :
+    runs_type -> state -> execution_ctx -> prealloc -> value -> value list ->
+    result **)
+
+let run_call_prealloc runs0 s c b vthis args =
+  match b with
+  | Coq_prealloc_global ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_global_eval ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_global_parse_int ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_global_parse_float ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_global_is_finite ->
+    let_binding (get_arg 0 args) (fun v ->
+      if_number (to_number runs0 s c v) (fun s0 n ->
+        res_ter s0
+          (res_val (Coq_value_prim (Coq_prim_bool
+            (neg
+              (or_decidable (number_comparable n nan)
+                (or_decidable (number_comparable n infinity)
+                  (number_comparable n neg_infinity)))))))))
+  | Coq_prealloc_global_is_nan ->
+    let_binding (get_arg 0 args) (fun v ->
+      if_number (to_number runs0 s c v) (fun s0 n ->
+        res_ter s0
+          (res_val (Coq_value_prim (Coq_prim_bool
+            (number_comparable n nan))))))
+  | Coq_prealloc_global_decode_uri ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_global_decode_uri_component ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_global_encode_uri ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_global_encode_uri_component ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_object ->
+    let_binding (get_arg 0 args) (fun value0 ->
+      match value0 with
+      | Coq_value_prim p ->
+        (match p with
+         | Coq_prim_undef -> run_construct_prealloc runs0 s c b args
+         | Coq_prim_null -> run_construct_prealloc runs0 s c b args
+         | Coq_prim_bool b0 -> to_object s value0
+         | Coq_prim_number n -> to_object s value0
+         | Coq_prim_string s0 -> to_object s value0)
+      | Coq_value_object o -> to_object s value0)
+  | Coq_prealloc_object_get_proto_of ->
+    let_binding (get_arg 0 args) (fun v ->
+      match v with
+      | Coq_value_prim p -> run_error s Coq_native_error_type
+      | Coq_value_object l ->
+        if_some (run_object_method object_proto_ s l) (fun proto ->
+          res_ter s (res_val proto)))
+  | Coq_prealloc_object_get_own_prop_descriptor ->
+    let_binding (get_arg 0 args) (fun v ->
+      match v with
+      | Coq_value_prim p -> run_error s Coq_native_error_type
+      | Coq_value_object l ->
+        if_string (to_string runs0 s c (get_arg (Pervasives.succ 0) args))
+          (fun s1 x ->
+          if_spec (runs0.runs_type_object_get_own_prop s1 c l x) (fun s2 d ->
+            from_prop_descriptor runs0 s2 c d)))
+  | Coq_prealloc_object_get_own_prop_name ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_object_create ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_object_define_prop ->
+    let_binding (get_arg 0 args) (fun o ->
+      let_binding (get_arg (Pervasives.succ 0) args) (fun p ->
+        let_binding (get_arg (Pervasives.succ (Pervasives.succ 0)) args)
+          (fun attr ->
+          match o with
+          | Coq_value_prim p0 -> run_error s Coq_native_error_type
+          | Coq_value_object l ->
+            if_string (to_string runs0 s c p) (fun s1 name ->
+              if_spec (run_to_descriptor runs0 s1 c attr) (fun s2 desc ->
+                if_bool (object_define_own_prop runs0 s2 c l name desc true)
+                  (fun s3 x -> res_ter s3 (res_val (Coq_value_object l))))))))
+  | Coq_prealloc_object_define_props ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_object_seal ->
+    let_binding (get_arg 0 args) (fun v ->
+      match v with
+      | Coq_value_prim p -> run_error s Coq_native_error_type
+      | Coq_value_object l ->
+        if_some (object_properties_keys_as_list_pickable_option s l)
+          (run_object_seal runs0 s c l))
+  | Coq_prealloc_object_freeze ->
+    let_binding (get_arg 0 args) (fun v ->
+      match v with
+      | Coq_value_prim p -> run_error s Coq_native_error_type
+      | Coq_value_object l ->
+        if_some (object_properties_keys_as_list_pickable_option s l)
+          (run_object_freeze runs0 s c l))
+  | Coq_prealloc_object_prevent_extensions ->
+    let_binding (get_arg 0 args) (fun v ->
+      match v with
+      | Coq_value_prim p -> run_error s Coq_native_error_type
+      | Coq_value_object l ->
+        if_some (object_binds_pickable_option s l) (fun o ->
+          let o1 = object_with_extension o false in
+          let s' = object_write s l o1 in
+          res_ter s' (res_val (Coq_value_object l))))
+  | Coq_prealloc_object_is_sealed ->
+    let_binding (get_arg 0 args) (fun v ->
+      match v with
+      | Coq_value_prim p -> run_error s Coq_native_error_type
+      | Coq_value_object l ->
+        if_some (object_properties_keys_as_list_pickable_option s l)
+          (run_object_is_sealed runs0 s c l))
+  | Coq_prealloc_object_is_frozen ->
+    let_binding (get_arg 0 args) (fun v ->
+      match v with
+      | Coq_value_prim p -> run_error s Coq_native_error_type
+      | Coq_value_object l ->
+        if_some (object_properties_keys_as_list_pickable_option s l)
+          (run_object_is_frozen runs0 s c l))
+  | Coq_prealloc_object_is_extensible ->
+    let_binding (get_arg 0 args) (fun v ->
+      match v with
+      | Coq_value_prim p -> run_error s Coq_native_error_type
+      | Coq_value_object l ->
+        if_some (run_object_method object_extensible_ s l) (fun r ->
+          res_ter s (res_val (Coq_value_prim (Coq_prim_bool r)))))
+  | Coq_prealloc_object_keys ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_object_keys_call ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_object_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_object_proto_to_string ->
+    (match vthis with
+     | Coq_value_prim p ->
+       (match p with
+        | Coq_prim_undef ->
+          result_out (Coq_out_ter (s,
+            (res_val (Coq_value_prim (Coq_prim_string
+              ("[object Undefined]"))))))
+        | Coq_prim_null ->
+          result_out (Coq_out_ter (s,
+            (res_val (Coq_value_prim (Coq_prim_string
+              ("[object Null]"))))))
+        | Coq_prim_bool b0 ->
+          if_object (to_object s vthis) (fun s1 l ->
+            if_some (run_object_method object_class_ s1 l) (fun s0 ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_string
+                  (append
+                    ("[object ")
+                    (append s0 ("]"))))))))
+        | Coq_prim_number n ->
+          if_object (to_object s vthis) (fun s1 l ->
+            if_some (run_object_method object_class_ s1 l) (fun s0 ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_string
+                  (append
+                    ("[object ")
+                    (append s0 ("]"))))))))
+        | Coq_prim_string s0 ->
+          if_object (to_object s vthis) (fun s1 l ->
+            if_some (run_object_method object_class_ s1 l) (fun s2 ->
+              res_ter s1
+                (res_val (Coq_value_prim (Coq_prim_string
+                  (append
+                    ("[object ")
+                    (append s2 ("]")))))))))
+     | Coq_value_object o ->
+       if_object (to_object s vthis) (fun s1 l ->
+         if_some (run_object_method object_class_ s1 l) (fun s0 ->
+           res_ter s1
+             (res_val (Coq_value_prim (Coq_prim_string
+               (append
+                 ("[object ")
+                 (append s0 ("]")))))))))
+  | Coq_prealloc_object_proto_value_of -> to_object s vthis
+  | Coq_prealloc_object_proto_has_own_prop ->
+    let_binding (get_arg 0 args) (fun v ->
+      if_string (to_string runs0 s c v) (fun s1 x ->
+        if_object (to_object s1 vthis) (fun s2 l ->
+          if_spec (runs0.runs_type_object_get_own_prop s2 c l x) (fun s3 d ->
+            match d with
+            | Coq_full_descriptor_undef ->
+              res_ter s3 (res_val (Coq_value_prim (Coq_prim_bool false)))
+            | Coq_full_descriptor_some a ->
+              res_ter s3 (res_val (Coq_value_prim (Coq_prim_bool true)))))))
+  | Coq_prealloc_object_proto_is_prototype_of ->
+    let_binding (get_arg 0 args) (fun v ->
+      match v with
+      | Coq_value_prim p ->
+        result_out (Coq_out_ter (s,
+          (res_val (Coq_value_prim (Coq_prim_bool false)))))
+      | Coq_value_object l ->
+        if_object (to_object s vthis) (fun s1 lo ->
+          runs0.runs_type_object_proto_is_prototype_of s1 lo l))
+  | Coq_prealloc_object_proto_prop_is_enumerable ->
+    let_binding (get_arg 0 args) (fun v ->
+      if_string (to_string runs0 s c v) (fun s1 x ->
+        if_object (to_object s1 vthis) (fun s2 l ->
+          if_spec (runs0.runs_type_object_get_own_prop s2 c l x) (fun s3 d ->
+            match d with
+            | Coq_full_descriptor_undef ->
+              res_ter s3 (res_val (Coq_value_prim (Coq_prim_bool false)))
+            | Coq_full_descriptor_some a ->
+              res_ter s3
+                (res_val (Coq_value_prim (Coq_prim_bool
+                  (attributes_enumerable a))))))))
+  | Coq_prealloc_function ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_function_proto ->
+    result_out (Coq_out_ter (s, (res_val (Coq_value_prim Coq_prim_undef))))
+  | Coq_prealloc_function_proto_to_string ->
+    if is_callable_dec s vthis
+    then (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+           ("Function.prototype.toString() is implementation dependent.")
+    else run_error s Coq_native_error_type
+  | Coq_prealloc_function_proto_apply ->
+    let_binding (get_arg 0 args) (fun thisArg ->
+      let_binding (get_arg (Pervasives.succ 0) args) (fun argArray ->
+        if is_callable_dec s vthis
+        then (match vthis with
+              | Coq_value_prim p ->
+                (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                  s
+                  ("Value is callable, but isn\'t an object.")
+              | Coq_value_object this ->
+                (match argArray with
+                 | Coq_value_prim p ->
+                   (match p with
+                    | Coq_prim_undef ->
+                      runs0.runs_type_call s c this thisArg []
+                    | Coq_prim_null ->
+                      runs0.runs_type_call s c this thisArg []
+                    | Coq_prim_bool b0 -> run_error s Coq_native_error_type
+                    | Coq_prim_number n -> run_error s Coq_native_error_type
+                    | Coq_prim_string s0 -> run_error s Coq_native_error_type)
+                 | Coq_value_object array ->
+                   if_value
+                     (run_object_get runs0 s c array
+                       ("length"))
+                     (fun s0 v ->
+                     if_spec (to_uint32 runs0 s0 c v) (fun s1 ilen ->
+                       if_spec
+                         (run_get_args_for_apply runs0 s1 c array 0. ilen)
+                         (fun s2 arguments ->
+                         runs0.runs_type_call s2 c this thisArg arguments)))))
+        else run_error s Coq_native_error_type))
+  | Coq_prealloc_function_proto_call ->
+    if is_callable_dec s vthis
+    then (match vthis with
+          | Coq_value_prim p ->
+            (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+              s
+              ("Value is callable, but isn\'t an object.")
+          | Coq_value_object this ->
+            let (thisArg, a) = get_arg_first_and_rest args in
+            runs0.runs_type_call s c this thisArg a)
+    else run_error s Coq_native_error_type
+  | Coq_prealloc_function_proto_bind ->
+    if is_callable_dec s vthis
+    then (match vthis with
+          | Coq_value_prim p ->
+            (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+              s
+              ("Value is callable, but isn\'t an object.")
+          | Coq_value_object this ->
+            let (vthisArg, a) = get_arg_first_and_rest args in
+            let_binding
+              (object_new (Coq_value_object (Coq_object_loc_prealloc
+                Coq_prealloc_object_proto))
+                ("Object")) (fun o1 ->
+              let_binding (object_with_get o1 Coq_builtin_get_function)
+                (fun o2 ->
+                let_binding
+                  (object_with_details o2 None None None (Some this) (Some
+                    vthisArg) (Some a) None) (fun o3 ->
+                  let_binding
+                    (object_set_class o3
+                      ("Function"))
+                    (fun o4 ->
+                    let_binding
+                      (object_set_proto o4 (Coq_value_object
+                        (Coq_object_loc_prealloc
+                        Coq_prealloc_function_proto))) (fun o5 ->
+                      let_binding
+                        (object_with_invokation o5 (Some
+                          Coq_construct_after_bind) (Some
+                          Coq_call_after_bind) (Some
+                          Coq_builtin_has_instance_after_bind)) (fun o6 ->
+                        let_binding (object_set_extensible o6 true)
+                          (fun o7 ->
+                          let (l, s') = object_alloc s o7 in
+                          let_binding
+                            (if_some
+                              (run_object_method object_class_ s' this)
+                              (fun class0 ->
+                              if string_comparable class0
+                                   ("Function")
+                              then if_number
+                                     (run_object_get runs0 s' c this
+                                       ("length"))
+                                     (fun s'0 n ->
+                                     if_spec
+                                       (to_int32 runs0 s'0 c (Coq_value_prim
+                                         (Coq_prim_number n)))
+                                       (fun s'1 ilen ->
+                                       if lt_int_decidable ilen
+                                            (my_Z_of_nat (LibList.length a))
+                                       then res_spec s'1 0.
+                                       else res_spec s'1
+                                              (Z.sub ilen
+                                                (my_Z_of_nat
+                                                  (LibList.length a)))))
+                              else res_spec s' 0.)) (fun vlength ->
+                            if_spec vlength (fun s'0 length0 ->
+                              let_binding { attributes_data_value =
+                                (Coq_value_prim (Coq_prim_number
+                                (of_int length0)));
+                                attributes_data_writable = false;
+                                attributes_data_enumerable = false;
+                                attributes_data_configurable = false }
+                                (fun a0 ->
+                                if_some
+                                  (object_heap_map_properties_pickable_option
+                                    s'0 l (fun p ->
+                                    Heap.write p
+                                      ("length")
+                                      (Coq_attributes_data_of a0)))
+                                  (fun s'1 ->
+                                  let_binding (Coq_value_object
+                                    (Coq_object_loc_prealloc
+                                    Coq_prealloc_throw_type_error))
+                                    (fun vthrower ->
+                                    let_binding { attributes_accessor_get =
+                                      vthrower; attributes_accessor_set =
+                                      vthrower;
+                                      attributes_accessor_enumerable = false;
+                                      attributes_accessor_configurable =
+                                      false } (fun a1 ->
+                                      if_bool
+                                        (object_define_own_prop runs0 s'1 c l
+                                          ("caller")
+                                          (descriptor_of_attributes
+                                            (Coq_attributes_accessor_of a1))
+                                          false) (fun s'2 x ->
+                                        if_bool
+                                          (object_define_own_prop runs0 s'2 c
+                                            l
+                                            ("arguments")
+                                            (descriptor_of_attributes
+                                              (Coq_attributes_accessor_of
+                                              a1)) false) (fun s'3 x0 ->
+                                          res_ter s'3
+                                            (res_val (Coq_value_object l))))))))))))))))))
+    else run_error s Coq_native_error_type
+  | Coq_prealloc_bool ->
+    result_out
+      (let_binding (get_arg 0 args) (fun v -> Coq_out_ter (s,
+        (res_val (Coq_value_prim (Coq_prim_bool
+          (convert_value_to_boolean v)))))))
+  | Coq_prealloc_bool_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_bool_proto_to_string ->
+    (match vthis with
+     | Coq_value_prim p ->
+       (match p with
+        | Coq_prim_undef -> run_error s Coq_native_error_type
+        | Coq_prim_null -> run_error s Coq_native_error_type
+        | Coq_prim_bool b0 ->
+          res_ter s
+            (res_val (Coq_value_prim (Coq_prim_string
+              (convert_bool_to_string b0))))
+        | Coq_prim_number n -> run_error s Coq_native_error_type
+        | Coq_prim_string s0 -> run_error s Coq_native_error_type)
+     | Coq_value_object l ->
+       if_some_or_default (run_object_method object_class_ s l)
+         (run_error s Coq_native_error_type) (fun s0 ->
+         if string_comparable s0
+              ("Boolean")
+         then if_some_or_default (run_object_method object_prim_value_ s l)
+                (run_error s Coq_native_error_type) (fun wo ->
+                match wo with
+                | Some v ->
+                  (match v with
+                   | Coq_value_prim p ->
+                     (match p with
+                      | Coq_prim_undef -> run_error s Coq_native_error_type
+                      | Coq_prim_null -> run_error s Coq_native_error_type
+                      | Coq_prim_bool b0 ->
+                        res_ter s
+                          (res_val (Coq_value_prim (Coq_prim_string
+                            (convert_bool_to_string b0))))
+                      | Coq_prim_number n ->
+                        run_error s Coq_native_error_type
+                      | Coq_prim_string s1 ->
+                        run_error s Coq_native_error_type)
+                   | Coq_value_object o -> run_error s Coq_native_error_type)
+                | None -> run_error s Coq_native_error_type)
+         else run_error s Coq_native_error_type))
+  | Coq_prealloc_bool_proto_value_of ->
+    (match vthis with
+     | Coq_value_prim p ->
+       (match p with
+        | Coq_prim_undef -> run_error s Coq_native_error_type
+        | Coq_prim_null -> run_error s Coq_native_error_type
+        | Coq_prim_bool b0 ->
+          res_ter s (res_val (Coq_value_prim (Coq_prim_bool b0)))
+        | Coq_prim_number n -> run_error s Coq_native_error_type
+        | Coq_prim_string s0 -> run_error s Coq_native_error_type)
+     | Coq_value_object l ->
+       if_some_or_default (run_object_method object_class_ s l)
+         (run_error s Coq_native_error_type) (fun s0 ->
+         if string_comparable s0
+              ("Boolean")
+         then if_some_or_default (run_object_method object_prim_value_ s l)
+                (run_error s Coq_native_error_type) (fun wo ->
+                match wo with
+                | Some v ->
+                  (match v with
+                   | Coq_value_prim p ->
+                     (match p with
+                      | Coq_prim_undef -> run_error s Coq_native_error_type
+                      | Coq_prim_null -> run_error s Coq_native_error_type
+                      | Coq_prim_bool b0 ->
+                        res_ter s
+                          (res_val (Coq_value_prim (Coq_prim_bool b0)))
+                      | Coq_prim_number n ->
+                        run_error s Coq_native_error_type
+                      | Coq_prim_string s1 ->
+                        run_error s Coq_native_error_type)
+                   | Coq_value_object o -> run_error s Coq_native_error_type)
+                | None -> run_error s Coq_native_error_type)
+         else run_error s Coq_native_error_type))
+  | Coq_prealloc_number ->
+    if list_eq_nil_decidable args
+    then result_out (Coq_out_ter (s,
+           (res_val (Coq_value_prim (Coq_prim_number zero)))))
+    else let v = get_arg 0 args in to_number runs0 s c v
+  | Coq_prealloc_number_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_number_proto_to_string ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_number_proto_value_of ->
+    (match vthis with
+     | Coq_value_prim p ->
+       (match p with
+        | Coq_prim_undef -> run_error s Coq_native_error_type
+        | Coq_prim_null -> run_error s Coq_native_error_type
+        | Coq_prim_bool b0 -> run_error s Coq_native_error_type
+        | Coq_prim_number n ->
+          res_ter s (res_val (Coq_value_prim (Coq_prim_number n)))
+        | Coq_prim_string s0 -> run_error s Coq_native_error_type)
+     | Coq_value_object l ->
+       if_some_or_default (run_object_method object_class_ s l)
+         (run_error s Coq_native_error_type) (fun s0 ->
+         if string_comparable s0 ("Number")
+         then if_some_or_default (run_object_method object_prim_value_ s l)
+                (run_error s Coq_native_error_type) (fun wo ->
+                match wo with
+                | Some v ->
+                  (match v with
+                   | Coq_value_prim p ->
+                     (match p with
+                      | Coq_prim_undef -> run_error s Coq_native_error_type
+                      | Coq_prim_null -> run_error s Coq_native_error_type
+                      | Coq_prim_bool b0 -> run_error s Coq_native_error_type
+                      | Coq_prim_number n ->
+                        res_ter s
+                          (res_val (Coq_value_prim (Coq_prim_number n)))
+                      | Coq_prim_string s1 ->
+                        run_error s Coq_native_error_type)
+                   | Coq_value_object o -> run_error s Coq_native_error_type)
+                | None -> run_error s Coq_native_error_type)
+         else run_error s Coq_native_error_type))
+  | Coq_prealloc_number_proto_to_fixed ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_number_proto_to_exponential ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_number_proto_to_precision ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_array ->
+    run_construct_prealloc runs0 s c Coq_prealloc_array args
+  | Coq_prealloc_array_is_array ->
+    let_binding (get_arg 0 args) (fun arg ->
+      match arg with
+      | Coq_value_prim p ->
+        res_ter s (res_val (Coq_value_prim (Coq_prim_bool false)))
+      | Coq_value_object arg0 ->
+        if_some (run_object_method object_class_ s arg0) (fun class0 ->
+          if string_comparable class0 ("Array")
+          then res_ter s (res_val (Coq_value_prim (Coq_prim_bool true)))
+          else res_ter s (res_val (Coq_value_prim (Coq_prim_bool false)))))
+  | Coq_prealloc_array_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_array_proto_to_string ->
+    if_object (to_object s vthis) (fun s0 array ->
+      if_value
+        (run_object_get runs0 s0 c array ("join"))
+        (fun s1 vfunc ->
+        if is_callable_dec s1 vfunc
+        then (match vfunc with
+              | Coq_value_prim p ->
+                (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+                  s1
+                  ("Value is callable, but isn\'t an object.")
+              | Coq_value_object func ->
+                runs0.runs_type_call s1 c func (Coq_value_object array) [])
+        else runs0.runs_type_call_prealloc s1 c
+               Coq_prealloc_object_proto_to_string (Coq_value_object array)
+               []))
+  | Coq_prealloc_array_proto_join ->
+    let_binding (get_arg 0 args) (fun vsep ->
+      if_object (to_object s vthis) (fun s0 l ->
+        if_value
+          (run_object_get runs0 s0 c l
+            ("length")) (fun s1 vlen ->
+          if_spec (to_uint32 runs0 s1 c vlen) (fun s2 ilen ->
+            let_binding
+              (if not_decidable
+                    (value_comparable vsep (Coq_value_prim Coq_prim_undef))
+               then vsep
+               else Coq_value_prim (Coq_prim_string (","))) (fun rsep ->
+              if_string (to_string runs0 s2 c rsep) (fun s3 sep ->
+                if int_comparable ilen (my_Z_of_nat 0)
+                then res_ter s3
+                       (res_val (Coq_value_prim (Coq_prim_string [])))
+                else let_binding (valueToStringForJoin runs0 s3 c l 0.)
+                       (fun sR ->
+                       if_spec sR (fun s4 sR0 ->
+                         run_array_join_elements runs0 s4 c l 1. ilen sep sR0))))))))
+  | Coq_prealloc_array_proto_pop ->
+    if_object (to_object s vthis) (fun s0 l ->
+      if_value
+        (run_object_get runs0 s0 c l
+          ("length")) (fun s1 vlen ->
+        if_spec (to_uint32 runs0 s1 c vlen) (fun s2 ilen ->
+          if int_comparable ilen (my_Z_of_nat 0)
+          then if_not_throw
+                 (object_put runs0 s2 c l
+                   ("length")
+                   (Coq_value_prim (Coq_prim_number zero)) throw_true)
+                 (fun s3 x ->
+                 result_out (Coq_out_ter (s3,
+                   (res_val (Coq_value_prim Coq_prim_undef)))))
+          else if_string
+                 (to_string runs0 s2 c (Coq_value_prim (Coq_prim_number
+                   (of_int (Z.sub ilen 1.))))) (fun s3 sindx ->
+                 if_value (run_object_get runs0 s3 c l sindx)
+                   (fun s4 velem ->
+                   if_not_throw
+                     (object_delete_default runs0 s4 c l sindx throw_true)
+                     (fun s5 x ->
+                     if_not_throw
+                       (object_put runs0 s5 c l
+                         ("length")
+                         (Coq_value_prim (Coq_prim_string sindx)) throw_true)
+                       (fun s6 x0 ->
+                       result_out (Coq_out_ter (s6, (res_val velem))))))))))
+  | Coq_prealloc_array_proto_push ->
+    if_object (to_object s vthis) (fun s0 l ->
+      if_value
+        (run_object_get runs0 s0 c l
+          ("length")) (fun s1 vlen ->
+        if_spec (to_uint32 runs0 s1 c vlen) (fun s2 ilen ->
+          push runs0 s2 c l args ilen)))
+  | Coq_prealloc_string ->
+    if list_eq_nil_decidable args
+    then res_ter s (res_val (Coq_value_prim (Coq_prim_string [])))
+    else let_binding (get_arg 0 args) (fun value0 ->
+           if_string (to_string runs0 s c value0) (fun s0 s1 ->
+             res_ter s0 (res_val (Coq_value_prim (Coq_prim_string s1)))))
+  | Coq_prealloc_string_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_string_proto_to_string ->
+    (match vthis with
+     | Coq_value_prim p ->
+       if type_comparable (type_of vthis) Coq_type_string
+       then res_ter s (res_val vthis)
+       else run_error s Coq_native_error_type
+     | Coq_value_object l ->
+       if_some (run_object_method object_class_ s l) (fun s0 ->
+         if string_comparable s0 ("String")
+         then run_object_prim_value s l
+         else run_error s Coq_native_error_type))
+  | Coq_prealloc_string_proto_value_of ->
+    (match vthis with
+     | Coq_value_prim p ->
+       if type_comparable (type_of vthis) Coq_type_string
+       then res_ter s (res_val vthis)
+       else run_error s Coq_native_error_type
+     | Coq_value_object l ->
+       if_some (run_object_method object_class_ s l) (fun s0 ->
+         if string_comparable s0 ("String")
+         then run_object_prim_value s l
+         else run_error s Coq_native_error_type))
+  | Coq_prealloc_string_proto_char_at ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_string_proto_char_code_at ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_math ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_mathop m ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_date ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_regexp ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_error ->
+    let_binding (get_arg 0 args) (fun v ->
+      build_error s (Coq_value_object (Coq_object_loc_prealloc
+        Coq_prealloc_error_proto)) v)
+  | Coq_prealloc_error_proto ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_native_error ne ->
+    let_binding (get_arg 0 args) (fun v ->
+      build_error s (Coq_value_object (Coq_object_loc_prealloc
+        (Coq_prealloc_native_error_proto ne))) v)
+  | Coq_prealloc_native_error_proto n ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_error_proto_to_string ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+  | Coq_prealloc_throw_type_error -> run_error s Coq_native_error_type
+  | Coq_prealloc_json ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Not implemented because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_not_yet_implemented)
+      (append
+        ("Call prealloc_")
+        (append (string_of_prealloc b)
+          (" not yet implemented")))
+
+(** val run_call :
+    runs_type -> state -> execution_ctx -> object_loc -> value -> value list
+    -> result **)
+
+let run_call runs0 s c l vthis args =
+  if_some (run_object_method object_call_ s l) (fun co ->
+    if_some co (fun c0 ->
+      match c0 with
+      | Coq_call_default -> entering_func_code runs0 s c l vthis args
+      | Coq_call_after_bind ->
+        if_some (run_object_method object_bound_args_ s l) (fun oarg ->
+          if_some oarg (fun boundArgs ->
+            if_some (run_object_method object_bound_this_ s l) (fun obnd ->
+              if_some obnd (fun boundThis ->
+                if_some (run_object_method object_target_function_ s l)
+                  (fun otrg ->
+                  if_some otrg (fun target ->
+                    let_binding (LibList.append boundArgs args)
+                      (fun arguments ->
+                      runs0.runs_type_call s c target boundThis arguments)))))))
+      | Coq_call_prealloc b -> run_call_prealloc runs0 s c b vthis args))
+
+(** val run_javascript : runs_type -> prog -> result **)
+
+let run_javascript runs0 p =
+  let p' = add_infos_prog strictness_false p in
+  let c = execution_ctx_initial (prog_intro_strictness p') in
+  if_void
+    (execution_ctx_binding_inst runs0 state_initial c Coq_codetype_global
+      None p' []) (fun s' -> runs0.runs_type_prog s' c p')
+
+(** val runs : int -> runs_type **)
+
+let rec runs max_step =
+  (fun fO fS n -> if n=0 then fO () else fS (n-1))
+    (fun _ -> { runs_type_expr = (fun s x x0 -> Coq_result_bottom s);
+    runs_type_stat = (fun s x x0 -> Coq_result_bottom s); runs_type_prog =
+    (fun s x x0 -> Coq_result_bottom s); runs_type_call =
+    (fun s x x0 x1 x2 -> Coq_result_bottom s); runs_type_call_prealloc =
+    (fun s x x0 x1 x2 -> Coq_result_bottom s); runs_type_construct =
+    (fun s x x0 x1 x2 -> Coq_result_bottom s);
+    runs_type_function_has_instance = (fun s x x0 -> Coq_result_bottom s);
+    runs_type_object_has_instance = (fun s x x0 x1 x2 -> Coq_result_bottom
+    s); runs_type_get_args_for_apply = (fun s x x0 x1 x2 -> Coq_result_bottom
+    s); runs_type_stat_while = (fun s x x0 x1 x2 x3 -> Coq_result_bottom s);
+    runs_type_stat_do_while = (fun s x x0 x1 x2 x3 -> Coq_result_bottom s);
+    runs_type_stat_for_loop = (fun s x x0 x1 x2 x3 x4 -> Coq_result_bottom
+    s); runs_type_object_delete = (fun s x x0 x1 x2 -> Coq_result_bottom s);
+    runs_type_object_get_own_prop = (fun s x x0 x1 -> Coq_result_bottom s);
+    runs_type_object_get_prop = (fun s x x0 x1 -> Coq_result_bottom s);
+    runs_type_object_get = (fun s x x0 x1 -> Coq_result_bottom s);
+    runs_type_object_proto_is_prototype_of = (fun s x x0 -> Coq_result_bottom
+    s); runs_type_object_put = (fun s x x0 x1 x2 x3 -> Coq_result_bottom s);
+    runs_type_equal = (fun s x x0 x1 -> Coq_result_bottom s);
+    runs_type_to_integer = (fun s x x0 -> Coq_result_bottom s);
+    runs_type_to_string = (fun s x x0 -> Coq_result_bottom s);
+    runs_type_array_join_elements = (fun s x x0 x1 x2 x3 x4 ->
+    Coq_result_bottom s); runs_type_array_element_list = (fun s x x0 x1 x2 ->
+    Coq_result_bottom s); runs_type_object_define_own_prop_array_loop =
+    (fun s x x0 x1 x2 x3 x4 x5 x6 -> Coq_result_bottom
+    s) })
+    (fun max_step' ->
+    let wrap = fun _ f s -> let runs' = runs max_step' in f runs' s in
+    { runs_type_expr = (wrap __ run_expr); runs_type_stat =
+    (wrap __ run_stat); runs_type_prog = (wrap __ run_prog); runs_type_call =
+    (wrap __ run_call); runs_type_call_prealloc =
+    (wrap __ run_call_prealloc); runs_type_construct =
+    (wrap __ run_construct); runs_type_function_has_instance =
+    (wrap __ run_function_has_instance); runs_type_object_has_instance =
+    (wrap __ run_object_has_instance); runs_type_get_args_for_apply =
+    (wrap __ run_get_args_for_apply); runs_type_stat_while =
+    (wrap __ run_stat_while); runs_type_stat_do_while =
+    (wrap __ run_stat_do_while); runs_type_stat_for_loop =
+    (wrap __ run_stat_for_loop); runs_type_object_delete =
+    (wrap __ object_delete); runs_type_object_get_own_prop =
+    (wrap __ run_object_get_own_prop); runs_type_object_get_prop =
+    (wrap __ run_object_get_prop); runs_type_object_get =
+    (wrap __ run_object_get); runs_type_object_proto_is_prototype_of =
+    (wrap __ object_proto_is_prototype_of); runs_type_object_put =
+    (wrap __ object_put); runs_type_equal = (wrap __ run_equal);
+    runs_type_to_integer = (wrap __ to_integer); runs_type_to_string =
+    (wrap __ to_string); runs_type_array_join_elements =
+    (wrap __ run_array_join_elements); runs_type_array_element_list =
+    (wrap __ run_array_element_list);
+    runs_type_object_define_own_prop_array_loop =
+    (wrap __ run_object_define_own_prop_array_loop) })
+    max_step
+
diff --git a/generator/tests/jsref/JsInterpreterMonads.ml b/generator/tests/jsref/JsInterpreterMonads.ml
new file mode 100644
index 0000000..7dff790
--- /dev/null
+++ b/generator/tests/jsref/JsInterpreterMonads.ml
@@ -0,0 +1,460 @@
+open JsCommon
+open JsNumber
+open JsSyntax
+open JsSyntaxAux
+open LibList
+open LibOption
+open Shared
+
+type __ = Obj.t
+
+type 't resultof =
+| Coq_result_some  [@f label0] of 't (** Auto Generated Attributes **)
+| Coq_result_not_yet_implemented [@f]  (** Auto Generated Attributes **)
+| Coq_result_impossible [@f]  (** Auto Generated Attributes **)
+| Coq_result_bottom  [@f label0] of state (** Auto Generated Attributes **)
+
+type 't specres = 't specret resultof
+
+(** val res_out : out -> 'a1 specres **)
+
+let res_out o =
+  Coq_result_some (Coq_specret_out o)
+
+(** val res_spec : state -> 'a1 -> 'a1 specres **)
+
+let res_spec s a =
+  Coq_result_some (Coq_specret_val (s, a))
+
+type retn = __ specret
+
+type result = retn resultof
+
+(** val res_ter : state -> res -> result **)
+
+let res_ter s r =
+  res_out (Coq_out_ter (s, r))
+
+type result_void = result
+
+(** val res_void : state -> result_void **)
+
+let res_void s =
+  res_out (out_void s)
+
+(** val out_from_retn : retn -> out **)
+
+let out_from_retn = function
+| Coq_specret_val (s, _) -> assert false (* absurd case *)
+| Coq_specret_out o -> o
+
+(** val result_out : out -> result **)
+
+let result_out o =
+  res_out o
+
+(** val get_arg : int -> value list -> value **)
+
+let get_arg =
+  nth_def (Coq_value_prim Coq_prim_undef)
+
+(** val get_arg_first_and_rest : value list -> value * value list **)
+
+let get_arg_first_and_rest lv =
+  ((get_arg 0 lv),
+    (match lv with
+     | [] -> []
+     | v :: rest -> rest))
+
+(** val destr_list : 'a1 list -> 'a2 -> ('a1 -> 'a2) -> 'a2 **)
+
+let destr_list l d f =
+  match l with
+  | [] -> d
+  | a :: l0 -> f a
+
+(** val if_empty_label :
+    state -> res -> (unit -> 'a1 resultof) -> 'a1 resultof **)
+
+let if_empty_label s r k =
+  if label_comparable r.res_label Coq_label_empty
+  then k ()
+  else (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+         s
+         ("[if_empty_label] received a normal result with non-empty label.")
+
+(** val if_some : 'a1 option -> ('a1 -> 'a2 resultof) -> 'a2 resultof **)
+
+let if_some op k =
+  match op with
+  | Some a -> k a
+  | None ->
+    (fun s ->
+  print_endline (__LOC__ ^ ": Stuck because: " ^ Prheap.string_of_char_list s) ;
+  Coq_result_impossible)
+      ("[if_some] called with [None].")
+
+(** val if_some_or_default : 'a2 option -> 'a1 -> ('a2 -> 'a1) -> 'a1 **)
+
+let if_some_or_default o d k =
+  option_case d k o
+
+(** val if_result_some :
+    'a1 resultof -> ('a1 -> 'a2 resultof) -> 'a2 resultof **)
+
+let if_result_some w k =
+  match w with
+  | Coq_result_some a -> k a
+  | Coq_result_not_yet_implemented -> Coq_result_not_yet_implemented
+  | Coq_result_impossible -> Coq_result_impossible
+  | Coq_result_bottom s0 -> Coq_result_bottom s0
+
+(** val if_out_some : result -> (out -> 'a1 resultof) -> 'a1 resultof **)
+
+let if_out_some w k =
+  if_result_some w (fun sp -> k (out_from_retn sp))
+
+(** val throw_result : result -> 'a1 specres **)
+
+let throw_result w =
+  if_out_some w (fun o -> res_out o)
+
+(** val if_ter : result -> (state -> res -> 'a1 specres) -> 'a1 specres **)
+
+let if_ter w k =
+  if_out_some w (fun o ->
+    match o with
+    | Coq_out_div -> res_out o
+    | Coq_out_ter (s0, r) -> k s0 r)
+
+(** val if_success_state :
+    resvalue -> result -> (state -> resvalue -> result) -> result **)
+
+let if_success_state rv w k =
+  if_ter w (fun s0 r ->
+    match r.res_type with
+    | Coq_restype_normal ->
+      if_empty_label s0 r (fun x ->
+        k s0
+          (if resvalue_comparable r.res_value Coq_resvalue_empty
+           then rv
+           else r.res_value))
+    | Coq_restype_break -> res_ter s0 (res_overwrite_value_if_empty rv r)
+    | Coq_restype_continue -> res_ter s0 (res_overwrite_value_if_empty rv r)
+    | Coq_restype_return -> res_ter s0 (res_overwrite_value_if_empty rv r)
+    | Coq_restype_throw -> res_ter s0 r)
+
+(** val if_success :
+    result -> (state -> resvalue -> 'a1 specres) -> 'a1 specres **)
+
+let if_success w k =
+  if_ter w (fun s0 r ->
+    match r.res_type with
+    | Coq_restype_normal -> if_empty_label s0 r (fun x -> k s0 r.res_value)
+    | Coq_restype_break -> res_out (Coq_out_ter (s0, r))
+    | Coq_restype_continue -> res_out (Coq_out_ter (s0, r))
+    | Coq_restype_return -> res_out (Coq_out_ter (s0, r))
+    | Coq_restype_throw -> res_out (Coq_out_ter (s0, r)))
+
+(** val if_void : result_void -> (state -> result) -> result **)
+
+let if_void w k =
+  if_success w (fun s rv ->
+    match rv with
+    | Coq_resvalue_empty -> k s
+    | Coq_resvalue_value v ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[if_void called] with non-void result value.")
+    | Coq_resvalue_ref r ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[if_void called] with non-void result value."))
+
+(** val if_not_throw : result -> (state -> res -> result) -> result **)
+
+let if_not_throw w k =
+  if_ter w (fun s0 r ->
+    match r.res_type with
+    | Coq_restype_normal -> k s0 r
+    | Coq_restype_break -> k s0 r
+    | Coq_restype_continue -> k s0 r
+    | Coq_restype_return -> k s0 r
+    | Coq_restype_throw -> w)
+
+(** val if_any_or_throw :
+    result -> (state -> res -> result) -> (state -> value -> result) ->
+    result **)
+
+let if_any_or_throw w k1 k2 =
+  if_ter w (fun s r ->
+    match r.res_type with
+    | Coq_restype_normal -> k1 s r
+    | Coq_restype_break -> k1 s r
+    | Coq_restype_continue -> k1 s r
+    | Coq_restype_return -> k1 s r
+    | Coq_restype_throw ->
+      (match r.res_value with
+       | Coq_resvalue_empty ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_any_or_throw] called with a non-value result.")
+       | Coq_resvalue_value v -> if_empty_label s r (fun x -> k2 s v)
+       | Coq_resvalue_ref r0 ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_any_or_throw] called with a non-value result.")))
+
+(** val if_success_or_return :
+    result -> (state -> result) -> (state -> resvalue -> result) -> result **)
+
+let if_success_or_return w k1 k2 =
+  if_ter w (fun s r ->
+    match r.res_type with
+    | Coq_restype_normal -> if_empty_label s r (fun x -> k1 s)
+    | Coq_restype_break -> w
+    | Coq_restype_continue -> w
+    | Coq_restype_return -> if_empty_label s r (fun x -> k2 s r.res_value)
+    | Coq_restype_throw -> w)
+
+(** val if_break : result -> (state -> res -> result) -> result **)
+
+let if_break w k =
+  if_ter w (fun s r ->
+    match r.res_type with
+    | Coq_restype_normal -> res_ter s r
+    | Coq_restype_break -> k s r
+    | Coq_restype_continue -> res_ter s r
+    | Coq_restype_return -> res_ter s r
+    | Coq_restype_throw -> res_ter s r)
+
+(** val if_value :
+    result -> (state -> value -> 'a1 specres) -> 'a1 specres **)
+
+let if_value w k =
+  if_success w (fun s rv ->
+    match rv with
+    | Coq_resvalue_empty ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[if_value] called with non-value.")
+    | Coq_resvalue_value v -> k s v
+    | Coq_resvalue_ref r ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[if_value] called with non-value."))
+
+(** val if_bool : result -> (state -> bool -> 'a1 specres) -> 'a1 specres **)
+
+let if_bool w k =
+  if_value w (fun s v ->
+    match v with
+    | Coq_value_prim p ->
+      (match p with
+       | Coq_prim_undef ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_bool] called with non-boolean value.")
+       | Coq_prim_null ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_bool] called with non-boolean value.")
+       | Coq_prim_bool b -> k s b
+       | Coq_prim_number n ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_bool] called with non-boolean value.")
+       | Coq_prim_string s0 ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_bool] called with non-boolean value."))
+    | Coq_value_object o ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[if_bool] called with non-boolean value."))
+
+(** val if_object :
+    result -> (state -> object_loc -> 'a1 specres) -> 'a1 specres **)
+
+let if_object w k =
+  if_value w (fun s v ->
+    match v with
+    | Coq_value_prim p ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[if_object] called on a primitive.")
+    | Coq_value_object l -> k s l)
+
+(** val if_string :
+    result -> (state -> char list -> 'a1 specres) -> 'a1 specres **)
+
+let if_string w k =
+  if_value w (fun s v ->
+    match v with
+    | Coq_value_prim p ->
+      (match p with
+       | Coq_prim_undef ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_string] called on a non-string value.")
+       | Coq_prim_null ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_string] called on a non-string value.")
+       | Coq_prim_bool b ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_string] called on a non-string value.")
+       | Coq_prim_number n ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_string] called on a non-string value.")
+       | Coq_prim_string s0 -> k s s0)
+    | Coq_value_object o ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[if_string] called on a non-string value."))
+
+(** val if_number :
+    result -> (state -> number -> 'a1 specres) -> 'a1 specres **)
+
+let if_number w k =
+  if_value w (fun s v ->
+    match v with
+    | Coq_value_prim p ->
+      (match p with
+       | Coq_prim_undef ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_number] called with non-number value.")
+       | Coq_prim_null ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_number] called with non-number value.")
+       | Coq_prim_bool b ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_number] called with non-number value.")
+       | Coq_prim_number n -> k s n
+       | Coq_prim_string s0 ->
+         (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s
+           ("[if_number] called with non-number value."))
+    | Coq_value_object o ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[if_number] called with non-number value."))
+
+(** val if_prim : result -> (state -> prim -> 'a1 specres) -> 'a1 specres **)
+
+let if_prim w k =
+  if_value w (fun s v ->
+    match v with
+    | Coq_value_prim w0 -> k s w0
+    | Coq_value_object o ->
+      (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+        s
+        ("[if_primitive] called on an object."))
+
+(** val convert_option_attributes :
+    attributes option -> full_descriptor option **)
+
+let convert_option_attributes =
+  map (fun a -> Coq_full_descriptor_some a)
+
+(** val if_abort : out -> (unit -> 'a1 resultof) -> 'a1 resultof **)
+
+let if_abort o k =
+  match o with
+  | Coq_out_div -> k ()
+  | Coq_out_ter (s0, r) ->
+    if restype_comparable r.res_type Coq_restype_normal
+    then (fun s message ->
+  print_endline (__LOC__ ^ ": Stuck!\nState:  " ^ Prheap.prstate true s
+    ^ "\nMessage:\t" ^ Prheap.string_of_char_list message) ;
+  Coq_result_impossible)
+           s0
+           ("[if_abort] received a normal result!")
+    else k ()
+
+(** val if_spec :
+    'a1 specres -> (state -> 'a1 -> 'a2 specres) -> 'a2 specres **)
+
+let if_spec w k =
+  if_result_some w (fun sp ->
+    match sp with
+    | Coq_specret_val (s0, a) -> k s0 a
+    | Coq_specret_out o -> if_abort o (fun x -> res_out o))
+
diff --git a/generator/tests/jsref/JsNumber.ml b/generator/tests/jsref/JsNumber.ml
new file mode 100644
index 0000000..4115839
--- /dev/null
+++ b/generator/tests/jsref/JsNumber.ml
@@ -0,0 +1,191 @@
+open Fappli_IEEE_bits
+open LibReflect
+
+type number = binary64
+
+(** val nan : number **)
+
+let nan = nan
+
+(** val zero : number **)
+
+let zero = 0.
+
+(** val neg_zero : number **)
+
+let neg_zero = (-0.)
+
+(** val one : float **)
+
+let one = 1.
+
+(** val infinity : number **)
+
+let infinity = infinity
+
+(** val neg_infinity : number **)
+
+let neg_infinity = neg_infinity
+
+(** val max_value : number **)
+
+let max_value = max_float
+
+(** val min_value : number **)
+
+let min_value = (Int64.float_of_bits Int64.one)
+
+(** val pi : number **)
+
+let pi = (4. *. atan 1.)
+
+(** val e : number **)
+
+let e = (exp 1.)
+
+(** val ln2 : number **)
+
+let ln2 = (log 2.)
+
+(** val from_string : char list -> number **)
+
+let from_string = (fun s ->
+    try
+      let s = (String.concat "" (List.map (String.make 1) s)) in
+      if s = "" then 0. else float_of_string s
+    with Failure "float_of_string" -> nan)
+   (* Note that we're using `float_of_string' there, which does not have the same
+      behavior than JavaScript.  For instance it will read "022" as 22 instead of
+      18, which should be the JavaScript result for it. *)
+
+(** val to_string : number -> char list **)
+
+let to_string = (fun f -> 
+    prerr_string ("Warning:  JsNumber.to_string called.  This might be responsible for errors.  Argument value:  " ^ string_of_float f ^ ".");
+    prerr_newline();
+    let string_of_number n =
+      let sfn = string_of_float n in
+      (if (sfn = "inf") then "Infinity" else
+       if (sfn = "-inf") then "-Infinity" else
+       if (sfn = "nan") then "NaN" else
+       let inum = int_of_float n in
+       if (float_of_int inum = n) then (string_of_int inum) else (string_of_float n)) in
+    let ret = ref [] in (* Ugly, but the API for OCaml string is not very functional... *)
+    String.iter (fun c -> ret := c :: !ret) (string_of_number f);
+    List.rev !ret)
+   (* Note that this is ugly, we should use the spec of JsNumber.to_string here (9.8.1). *)
+
+(** val neg : number -> number **)
+
+let neg = (~-.)
+
+(** val floor : number -> number **)
+
+let floor = floor
+
+(** val absolute : number -> number **)
+
+let absolute = abs_float
+
+(** val sign : number -> number **)
+
+let sign = (fun f -> float_of_int (compare f 0.))
+
+(** val lt_bool : number -> number -> bool **)
+
+let lt_bool = (<)
+
+(** val add : number -> number -> number **)
+
+let add = (+.)
+
+(** val sub : number -> number -> number **)
+
+let sub = (-.)
+
+(** val fmod : number -> number -> number **)
+
+let fmod = mod_float
+
+(** val mult : number -> number -> number **)
+
+let mult = ( *. )
+
+(** val div : number -> number -> number **)
+
+let div = (/.)
+
+(** val number_comparable : number coq_Comparable **)
+
+let number_comparable = (fun n1 n2 -> 0 = compare n1 n2)
+
+(** val of_int : float -> number **)
+
+let of_int = fun x -> x
+
+(** val to_int32 : number -> float **)
+
+let to_int32 = fun n ->
+  match classify_float n with
+  | FP_normal | FP_subnormal ->
+    let i32 = 2. ** 32. in
+    let i31 = 2. ** 31. in
+    let posint = (if n < 0. then (-1.) else 1.) *. (floor (abs_float n)) in
+    let int32bit =
+      let smod = mod_float posint i32 in
+      if smod < 0. then smod +. i32 else smod
+    in
+    (if int32bit >= i31 then int32bit -. i32 else int32bit)
+  | _ -> 0.
+
+(** val to_uint32 : number -> float **)
+
+let to_uint32 = fun n ->
+  match classify_float n with
+  | FP_normal | FP_subnormal ->
+    let i32 = 2. ** 32. in
+    let posint = (if n < 0. then (-1.) else 1.) *. (floor (abs_float n)) in
+    let int32bit =
+      let smod = mod_float posint i32 in
+      if smod < 0. then smod +. i32 else smod
+    in
+    int32bit
+  | _ -> 0.
+
+(** val modulo_32 : float -> float **)
+
+let modulo_32 = (fun x -> let r = mod_float x 32. in if x < 0. then r +. 32. else r)
+
+(** val int32_bitwise_not : float -> float **)
+
+let int32_bitwise_not = fun x -> Int32.to_float (Int32.lognot (Int32.of_float x))
+
+(** val int32_bitwise_and : float -> float -> float **)
+
+let int32_bitwise_and = fun x y -> Int32.to_float (Int32.logand (Int32.of_float x) (Int32.of_float y))
+
+(** val int32_bitwise_or : float -> float -> float **)
+
+let int32_bitwise_or = fun x y -> Int32.to_float (Int32.logor (Int32.of_float x) (Int32.of_float y))
+
+(** val int32_bitwise_xor : float -> float -> float **)
+
+let int32_bitwise_xor = fun x y -> Int32.to_float (Int32.logxor (Int32.of_float x) (Int32.of_float y))
+
+(** val int32_left_shift : float -> float -> float **)
+
+let int32_left_shift = (fun x y -> Int32.to_float (Int32.shift_left (Int32.of_float x) (int_of_float y)))
+
+(** val int32_right_shift : float -> float -> float **)
+
+let int32_right_shift = (fun x y -> Int32.to_float (Int32.shift_right (Int32.of_float x) (int_of_float y)))
+
+(** val uint32_right_shift : float -> float -> float **)
+
+let uint32_right_shift = (fun x y ->
+  let i31 = 2. ** 31. in
+  let i32 = 2. ** 32. in
+  let newx = if x >= i31 then x -. i32 else x in
+  let r = Int32.to_float (Int32.shift_right_logical (Int32.of_float newx) (int_of_float y)) in
+  if r < 0. then r +. i32 else r)
+
diff --git a/generator/tests/jsref/JsPreliminary.ml b/generator/tests/jsref/JsPreliminary.ml
new file mode 100644
index 0000000..ea315b8
--- /dev/null
+++ b/generator/tests/jsref/JsPreliminary.ml
@@ -0,0 +1,228 @@
+open JsCommon
+open JsNumber
+open JsSyntax
+open JsSyntaxAux
+open LibReflect
+open LibString
+open Shared
+
+(** val convert_number_to_bool : number -> bool **)
+
+let convert_number_to_bool n =
+  if or_decidable (number_comparable n zero)
+       (or_decidable (number_comparable n neg_zero)
+         (number_comparable n nan))
+  then false
+  else true
+
+(** val convert_string_to_bool : char list -> bool **)
+
+let convert_string_to_bool s =
+  if string_comparable s [] then false else true
+
+(** val convert_prim_to_boolean : prim -> bool **)
+
+let convert_prim_to_boolean = function
+| Coq_prim_undef -> false
+| Coq_prim_null -> false
+| Coq_prim_bool b -> b
+| Coq_prim_number n -> convert_number_to_bool n
+| Coq_prim_string s -> convert_string_to_bool s
+
+(** val convert_value_to_boolean : value -> bool **)
+
+let convert_value_to_boolean = function
+| Coq_value_prim p -> convert_prim_to_boolean p
+| Coq_value_object o -> true
+
+(** val convert_prim_to_number : prim -> number **)
+
+let convert_prim_to_number = function
+| Coq_prim_undef -> nan
+| Coq_prim_null -> zero
+| Coq_prim_bool b -> if b then one else zero
+| Coq_prim_number n -> n
+| Coq_prim_string s -> from_string s
+
+(** val convert_number_to_integer : number -> number **)
+
+let convert_number_to_integer n =
+  if number_comparable n nan
+  then zero
+  else if or_decidable (number_comparable n zero)
+            (or_decidable (number_comparable n neg_zero)
+              (or_decidable (number_comparable n infinity)
+                (number_comparable n neg_infinity)))
+       then n
+       else mult (sign n) (floor (absolute n))
+
+(** val convert_bool_to_string : bool -> char list **)
+
+let convert_bool_to_string = function
+| true -> "true"
+| false -> "false"
+
+(** val convert_prim_to_string : prim -> char list **)
+
+let convert_prim_to_string = function
+| Coq_prim_undef ->
+  "undefined"
+| Coq_prim_null -> "null"
+| Coq_prim_bool b -> convert_bool_to_string b
+| Coq_prim_number n -> to_string n
+| Coq_prim_string s -> s
+
+(** val equality_test_for_same_type : coq_type -> value -> value -> bool **)
+
+let equality_test_for_same_type ty v1 v2 =
+  match ty with
+  | Coq_type_undef -> true
+  | Coq_type_null -> true
+  | Coq_type_bool -> value_comparable v1 v2
+  | Coq_type_number ->
+    (match v1 with
+     | Coq_value_prim p ->
+       (match p with
+        | Coq_prim_undef -> false
+        | Coq_prim_null -> false
+        | Coq_prim_bool b -> false
+        | Coq_prim_number n1 ->
+          (match v2 with
+           | Coq_value_prim p0 ->
+             (match p0 with
+              | Coq_prim_undef -> false
+              | Coq_prim_null -> false
+              | Coq_prim_bool b -> false
+              | Coq_prim_number n2 ->
+                if number_comparable n1 nan
+                then false
+                else if number_comparable n2 nan
+                     then false
+                     else if and_decidable (number_comparable n1 zero)
+                               (number_comparable n2 neg_zero)
+                          then true
+                          else if and_decidable
+                                    (number_comparable n1 neg_zero)
+                                    (number_comparable n2 zero)
+                               then true
+                               else number_comparable n1 n2
+              | Coq_prim_string s -> false)
+           | Coq_value_object o -> false)
+        | Coq_prim_string s -> false)
+     | Coq_value_object o -> false)
+  | Coq_type_string -> value_comparable v1 v2
+  | Coq_type_object -> value_comparable v1 v2
+
+(** val strict_equality_test : value -> value -> bool **)
+
+let strict_equality_test v1 v2 =
+  let ty1 = type_of v1 in
+  let ty2 = type_of v2 in
+  if type_comparable ty1 ty2
+  then equality_test_for_same_type ty1 v1 v2
+  else false
+
+(** val inequality_test_number : number -> number -> prim **)
+
+let inequality_test_number n1 n2 =
+  if or_decidable (number_comparable n1 nan) (number_comparable n2 nan)
+  then Coq_prim_undef
+  else if number_comparable n1 n2
+       then Coq_prim_bool false
+       else if and_decidable (number_comparable n1 zero)
+                 (number_comparable n2 neg_zero)
+            then Coq_prim_bool false
+            else if and_decidable (number_comparable n1 neg_zero)
+                      (number_comparable n2 zero)
+                 then Coq_prim_bool false
+                 else if number_comparable n1 infinity
+                      then Coq_prim_bool false
+                      else if number_comparable n2 infinity
+                           then Coq_prim_bool true
+                           else if number_comparable n2 neg_infinity
+                                then Coq_prim_bool false
+                                else if number_comparable n1 neg_infinity
+                                     then Coq_prim_bool true
+                                     else Coq_prim_bool (lt_bool n1 n2)
+
+(** val inequality_test_string : char list -> char list -> bool **)
+
+let rec inequality_test_string s1 s2 =
+  match s1 with
+  | [] ->
+    (match s2 with
+     | [] -> false
+     | a::s -> true)
+  | c1::s1' ->
+    (match s2 with
+     | [] -> false
+     | c2::s2' ->
+       if ascii_comparable c1 c2
+       then inequality_test_string s1' s2'
+       else lt_int_decidable (int_of_char c1) (int_of_char c2))
+
+(** val inequality_test_primitive : prim -> prim -> prim **)
+
+let inequality_test_primitive w1 w2 =
+  match w1 with
+  | Coq_prim_undef ->
+    inequality_test_number (convert_prim_to_number w1)
+      (convert_prim_to_number w2)
+  | Coq_prim_null ->
+    inequality_test_number (convert_prim_to_number w1)
+      (convert_prim_to_number w2)
+  | Coq_prim_bool b ->
+    inequality_test_number (convert_prim_to_number w1)
+      (convert_prim_to_number w2)
+  | Coq_prim_number n ->
+    inequality_test_number (convert_prim_to_number w1)
+      (convert_prim_to_number w2)
+  | Coq_prim_string s1 ->
+    (match w2 with
+     | Coq_prim_undef ->
+       inequality_test_number (convert_prim_to_number w1)
+         (convert_prim_to_number w2)
+     | Coq_prim_null ->
+       inequality_test_number (convert_prim_to_number w1)
+         (convert_prim_to_number w2)
+     | Coq_prim_bool b ->
+       inequality_test_number (convert_prim_to_number w1)
+         (convert_prim_to_number w2)
+     | Coq_prim_number n ->
+       inequality_test_number (convert_prim_to_number w1)
+         (convert_prim_to_number w2)
+     | Coq_prim_string s2 -> Coq_prim_bool (inequality_test_string s1 s2))
+
+(** val typeof_prim : prim -> char list **)
+
+let typeof_prim = function
+| Coq_prim_undef ->
+  "undefined"
+| Coq_prim_null -> "object"
+| Coq_prim_bool b -> "boolean"
+| Coq_prim_number n -> "number"
+| Coq_prim_string s -> "string"
+
+(** val string_of_propname : propname -> prop_name **)
+
+let string_of_propname = function
+| Coq_propname_identifier s -> s
+| Coq_propname_string s -> s
+| Coq_propname_number n -> to_string n
+
+(** val string_of_native_error : native_error -> char list **)
+
+let string_of_native_error = function
+| Coq_native_error_eval ->
+  "EvalError"
+| Coq_native_error_range ->
+  "RangeError"
+| Coq_native_error_ref ->
+  "ReferenceError"
+| Coq_native_error_syntax ->
+  "SyntaxError"
+| Coq_native_error_type ->
+  "TypeError"
+| Coq_native_error_uri ->
+  "URIError"
+
diff --git a/generator/tests/jsref/JsSyntax.ml b/generator/tests/jsref/JsSyntax.ml
new file mode 100644
index 0000000..11f0e40
--- /dev/null
+++ b/generator/tests/jsref/JsSyntax.ml
@@ -0,0 +1,681 @@
+open JsNumber
+open LibHeap
+open LibReflect
+open LibStream
+open Shared
+
+module Heap = HeapGen(HeapList)
+
+type unary_op =
+| Coq_unary_op_delete [@f]  (** Auto Generated Attributes **)
+| Coq_unary_op_void [@f]  (** Auto Generated Attributes **)
+| Coq_unary_op_typeof [@f]  (** Auto Generated Attributes **)
+| Coq_unary_op_post_incr [@f]  (** Auto Generated Attributes **)
+| Coq_unary_op_post_decr [@f]  (** Auto Generated Attributes **)
+| Coq_unary_op_pre_incr [@f]  (** Auto Generated Attributes **)
+| Coq_unary_op_pre_decr [@f]  (** Auto Generated Attributes **)
+| Coq_unary_op_add [@f]  (** Auto Generated Attributes **)
+| Coq_unary_op_neg [@f]  (** Auto Generated Attributes **)
+| Coq_unary_op_bitwise_not [@f]  (** Auto Generated Attributes **)
+| Coq_unary_op_not [@f]  (** Auto Generated Attributes **)
+
+type binary_op =
+| Coq_binary_op_mult [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_div [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_mod [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_add [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_sub [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_left_shift [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_right_shift [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_unsigned_right_shift [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_lt [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_gt [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_le [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_ge [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_instanceof [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_in [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_equal [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_disequal [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_strict_equal [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_strict_disequal [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_bitwise_and [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_bitwise_or [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_bitwise_xor [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_and [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_or [@f]  (** Auto Generated Attributes **)
+| Coq_binary_op_coma [@f]  (** Auto Generated Attributes **)
+
+type literal =
+| Coq_literal_null [@f]  (** Auto Generated Attributes **)
+| Coq_literal_bool  [@f label0] of bool (** Auto Generated Attributes **)
+| Coq_literal_number  [@f label0] of number (** Auto Generated Attributes **)
+| Coq_literal_string  [@f label0] of char list (** Auto Generated Attributes **)
+
+type label =
+| Coq_label_empty [@f]  (** Auto Generated Attributes **)
+| Coq_label_string  [@f label0] of char list (** Auto Generated Attributes **)
+
+type label_set = label list
+
+type strictness_flag = bool
+
+(** val strictness_false : strictness_flag **)
+
+let strictness_false =
+  false
+
+type propname =
+| Coq_propname_identifier  [@f label0] of char list (** Auto Generated Attributes **)
+| Coq_propname_string  [@f label0] of char list (** Auto Generated Attributes **)
+| Coq_propname_number  [@f label0] of number (** Auto Generated Attributes **)
+
+type expr =
+| Coq_expr_this [@f]  (** Auto Generated Attributes **)
+| Coq_expr_identifier  [@f label0] of char list (** Auto Generated Attributes **)
+| Coq_expr_literal  [@f label0] of literal (** Auto Generated Attributes **)
+| Coq_expr_object  [@f label0, label1] of (propname * propbody) list (** Auto Generated Attributes **)
+| Coq_expr_array  [@f label0] of expr option list (** Auto Generated Attributes **)
+| Coq_expr_function  [@f label0, label1, label2] of char list option * char list list * funcbody (** Auto Generated Attributes **)
+| Coq_expr_access  [@f label0, label1] of expr * expr (** Auto Generated Attributes **)
+| Coq_expr_member  [@f label0, label1] of expr * char list (** Auto Generated Attributes **)
+| Coq_expr_new  [@f label0, label1] of expr * expr list (** Auto Generated Attributes **)
+| Coq_expr_call  [@f label0, label1] of expr * expr list (** Auto Generated Attributes **)
+| Coq_expr_unary_op  [@f label0, label1] of unary_op * expr (** Auto Generated Attributes **)
+| Coq_expr_binary_op  [@f label0, label1, label2] of expr * binary_op * expr (** Auto Generated Attributes **)
+| Coq_expr_conditional  [@f label0, label1, label2] of expr * expr * expr (** Auto Generated Attributes **)
+| Coq_expr_assign  [@f label0, label1, label2] of expr * binary_op option * expr (** Auto Generated Attributes **)
+and propbody =
+| Coq_propbody_val  [@f label0] of expr (** Auto Generated Attributes **)
+| Coq_propbody_get  [@f label0] of funcbody (** Auto Generated Attributes **)
+| Coq_propbody_set  [@f label0, label1] of char list list * funcbody (** Auto Generated Attributes **)
+and funcbody =
+| Coq_funcbody_intro  [@f label0, label1] of prog * char list (** Auto Generated Attributes **)
+and stat =
+| Coq_stat_expr  [@f label0] of expr (** Auto Generated Attributes **)
+| Coq_stat_label  [@f label0, label1] of char list * stat (** Auto Generated Attributes **)
+| Coq_stat_block  [@f label0] of stat list (** Auto Generated Attributes **)
+| Coq_stat_var_decl  [@f label0, label1] of (char list * expr option) list (** Auto Generated Attributes **)
+| Coq_stat_if  [@f label0, label1, label2] of expr * stat * stat option (** Auto Generated Attributes **)
+| Coq_stat_do_while  [@f label0, label1, label2] of label_set * stat * expr (** Auto Generated Attributes **)
+| Coq_stat_while  [@f label0, label1, label2] of label_set * expr * stat (** Auto Generated Attributes **)
+| Coq_stat_with  [@f label0, label1] of expr * stat (** Auto Generated Attributes **)
+| Coq_stat_throw  [@f label0] of expr (** Auto Generated Attributes **)
+| Coq_stat_return  [@f label0] of expr option (** Auto Generated Attributes **)
+| Coq_stat_break  [@f label0] of label (** Auto Generated Attributes **)
+| Coq_stat_continue  [@f label0] of label (** Auto Generated Attributes **)
+| Coq_stat_try  [@f label0, label1, label2, label3] of stat * (char list * stat) option * stat option (** Auto Generated Attributes **)
+| Coq_stat_for  [@f label0, label1, label2, label3, label4] of label_set * expr option * expr option * expr option * stat (** Auto Generated Attributes **)
+| Coq_stat_for_var  [@f label0, label1, label2] of label_set * (char list * expr option) list (** Auto Generated Attributes **)
+   * expr option * expr option * stat
+| Coq_stat_for_in  [@f label0, label1, label2, label3] of label_set * expr * expr * stat (** Auto Generated Attributes **)
+| Coq_stat_for_in_var  [@f label0, label1, label2, label3, label4] of label_set * char list * expr option * expr * stat (** Auto Generated Attributes **)
+| Coq_stat_debugger [@f]  (** Auto Generated Attributes **)
+| Coq_stat_switch  [@f label0, label1, label2] of label_set * expr * switchbody (** Auto Generated Attributes **)
+and switchbody =
+| Coq_switchbody_nodefault  [@f label0] of switchclause list (** Auto Generated Attributes **)
+| Coq_switchbody_withdefault  [@f label0, label1] of switchclause list * stat list (** Auto Generated Attributes **)
+   * switchclause list
+and switchclause =
+| Coq_switchclause_intro  [@f label0, label1] of expr * stat list (** Auto Generated Attributes **)
+and prog =
+| Coq_prog_intro  [@f label0, label1] of strictness_flag * element list (** Auto Generated Attributes **)
+and element =
+| Coq_element_stat  [@f label0] of stat (** Auto Generated Attributes **)
+| Coq_element_func_decl  [@f label0, label1, label2] of char list * char list list * funcbody (** Auto Generated Attributes **)
+
+type propdefs = (propname * propbody) list
+
+type elements = element list
+
+type funcdecl = { funcdecl_name : char list;
+                  funcdecl_parameters : char list list;
+                  funcdecl_body : funcbody }
+
+(** val funcdecl_name : funcdecl -> char list **)
+
+let funcdecl_name x = x.funcdecl_name
+
+(** val funcdecl_parameters : funcdecl -> char list list **)
+
+let funcdecl_parameters x = x.funcdecl_parameters
+
+(** val funcdecl_body : funcdecl -> funcbody **)
+
+let funcdecl_body x = x.funcdecl_body
+
+type mathop =
+| Coq_mathop_abs [@f]  (** Auto Generated Attributes **)
+
+type native_error =
+| Coq_native_error_eval [@f]  (** Auto Generated Attributes **)
+| Coq_native_error_range [@f]  (** Auto Generated Attributes **)
+| Coq_native_error_ref [@f]  (** Auto Generated Attributes **)
+| Coq_native_error_syntax [@f]  (** Auto Generated Attributes **)
+| Coq_native_error_type [@f]  (** Auto Generated Attributes **)
+| Coq_native_error_uri [@f]  (** Auto Generated Attributes **)
+
+type prealloc =
+| Coq_prealloc_global [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_global_eval [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_global_parse_int [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_global_parse_float [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_global_is_finite [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_global_is_nan [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_global_decode_uri [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_global_decode_uri_component [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_global_encode_uri [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_global_encode_uri_component [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_get_proto_of [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_get_own_prop_descriptor [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_get_own_prop_name [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_create [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_define_prop [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_define_props [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_seal [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_freeze [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_prevent_extensions [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_is_sealed [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_is_frozen [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_is_extensible [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_keys [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_keys_call [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_proto [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_proto_to_string [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_proto_value_of [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_proto_has_own_prop [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_proto_is_prototype_of [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_object_proto_prop_is_enumerable [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_function [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_function_proto [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_function_proto_to_string [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_function_proto_apply [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_function_proto_call [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_function_proto_bind [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_bool [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_bool_proto [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_bool_proto_to_string [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_bool_proto_value_of [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_number [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_number_proto [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_number_proto_to_string [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_number_proto_value_of [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_number_proto_to_fixed [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_number_proto_to_exponential [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_number_proto_to_precision [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_array [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_array_is_array [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_array_proto [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_array_proto_to_string [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_array_proto_join [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_array_proto_pop [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_array_proto_push [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_string [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_string_proto [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_string_proto_to_string [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_string_proto_value_of [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_string_proto_char_at [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_string_proto_char_code_at [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_math [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_mathop  [@f label0] of mathop (** Auto Generated Attributes **)
+| Coq_prealloc_date [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_regexp [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_error [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_error_proto [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_native_error  [@f label0] of native_error (** Auto Generated Attributes **)
+| Coq_prealloc_native_error_proto  [@f label0] of native_error (** Auto Generated Attributes **)
+| Coq_prealloc_error_proto_to_string [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_throw_type_error [@f]  (** Auto Generated Attributes **)
+| Coq_prealloc_json [@f]  (** Auto Generated Attributes **)
+
+type call =
+| Coq_call_default [@f]  (** Auto Generated Attributes **)
+| Coq_call_after_bind [@f]  (** Auto Generated Attributes **)
+| Coq_call_prealloc  [@f label0] of prealloc (** Auto Generated Attributes **)
+
+type construct =
+| Coq_construct_default [@f]  (** Auto Generated Attributes **)
+| Coq_construct_after_bind [@f]  (** Auto Generated Attributes **)
+| Coq_construct_prealloc  [@f label0] of prealloc (** Auto Generated Attributes **)
+
+type builtin_has_instance =
+| Coq_builtin_has_instance_function [@f]  (** Auto Generated Attributes **)
+| Coq_builtin_has_instance_after_bind [@f]  (** Auto Generated Attributes **)
+
+type builtin_get =
+| Coq_builtin_get_default [@f]  (** Auto Generated Attributes **)
+| Coq_builtin_get_function [@f]  (** Auto Generated Attributes **)
+| Coq_builtin_get_args_obj [@f]  (** Auto Generated Attributes **)
+
+type builtin_get_own_prop =
+| Coq_builtin_get_own_prop_default [@f]  (** Auto Generated Attributes **)
+| Coq_builtin_get_own_prop_args_obj [@f]  (** Auto Generated Attributes **)
+| Coq_builtin_get_own_prop_string [@f]  (** Auto Generated Attributes **)
+
+type builtin_get_prop =
+| Coq_builtin_get_prop_default [@f]  (** Auto Generated Attributes **)
+
+type builtin_put =
+| Coq_builtin_put_default [@f]  (** Auto Generated Attributes **)
+
+type builtin_can_put =
+| Coq_builtin_can_put_default [@f]  (** Auto Generated Attributes **)
+
+type builtin_has_prop =
+| Coq_builtin_has_prop_default [@f]  (** Auto Generated Attributes **)
+
+type builtin_delete =
+| Coq_builtin_delete_default [@f]  (** Auto Generated Attributes **)
+| Coq_builtin_delete_args_obj [@f]  (** Auto Generated Attributes **)
+
+type builtin_default_value =
+| Coq_builtin_default_value_default [@f]  (** Auto Generated Attributes **)
+
+type builtin_define_own_prop =
+| Coq_builtin_define_own_prop_default [@f]  (** Auto Generated Attributes **)
+| Coq_builtin_define_own_prop_array [@f]  (** Auto Generated Attributes **)
+| Coq_builtin_define_own_prop_args_obj [@f]  (** Auto Generated Attributes **)
+
+type object_loc =
+| Coq_object_loc_normal  [@f label0] of int (** Auto Generated Attributes **)
+| Coq_object_loc_prealloc  [@f label0] of prealloc (** Auto Generated Attributes **)
+
+type prim =
+| Coq_prim_undef [@f]  (** Auto Generated Attributes **)
+| Coq_prim_null [@f]  (** Auto Generated Attributes **)
+| Coq_prim_bool  [@f label0] of bool (** Auto Generated Attributes **)
+| Coq_prim_number  [@f label0] of number (** Auto Generated Attributes **)
+| Coq_prim_string  [@f label0] of char list (** Auto Generated Attributes **)
+
+type value =
+| Coq_value_prim  [@f label0] of prim (** Auto Generated Attributes **)
+| Coq_value_object  [@f label0] of object_loc (** Auto Generated Attributes **)
+
+type coq_type =
+| Coq_type_undef [@f]  (** Auto Generated Attributes **)
+| Coq_type_null [@f]  (** Auto Generated Attributes **)
+| Coq_type_bool [@f]  (** Auto Generated Attributes **)
+| Coq_type_number [@f]  (** Auto Generated Attributes **)
+| Coq_type_string [@f]  (** Auto Generated Attributes **)
+| Coq_type_object [@f]  (** Auto Generated Attributes **)
+
+type attributes_data = { attributes_data_value : value;
+                         attributes_data_writable : bool;
+                         attributes_data_enumerable : bool;
+                         attributes_data_configurable : bool }
+
+(** val attributes_data_value : attributes_data -> value **)
+
+let attributes_data_value x = x.attributes_data_value
+
+(** val attributes_data_writable : attributes_data -> bool **)
+
+let attributes_data_writable x = x.attributes_data_writable
+
+(** val attributes_data_enumerable : attributes_data -> bool **)
+
+let attributes_data_enumerable x = x.attributes_data_enumerable
+
+(** val attributes_data_configurable : attributes_data -> bool **)
+
+let attributes_data_configurable x = x.attributes_data_configurable
+
+type attributes_accessor = { attributes_accessor_get : value;
+                             attributes_accessor_set : value;
+                             attributes_accessor_enumerable : bool;
+                             attributes_accessor_configurable : bool }
+
+(** val attributes_accessor_get : attributes_accessor -> value **)
+
+let attributes_accessor_get x = x.attributes_accessor_get
+
+(** val attributes_accessor_set : attributes_accessor -> value **)
+
+let attributes_accessor_set x = x.attributes_accessor_set
+
+(** val attributes_accessor_enumerable : attributes_accessor -> bool **)
+
+let attributes_accessor_enumerable x = x.attributes_accessor_enumerable
+
+(** val attributes_accessor_configurable : attributes_accessor -> bool **)
+
+let attributes_accessor_configurable x = x.attributes_accessor_configurable
+
+type attributes =
+| Coq_attributes_data_ [@f label0] of of attributes_data (** Auto Generated Attributes **)
+| Coq_attributes_accessor_ [@f label0] of of attributes_accessor (** Auto Generated Attributes **)
+
+type descriptor = { descriptor_value : value option;
+                    descriptor_writable : bool option;
+                    descriptor_get : value option;
+                    descriptor_set : value option;
+                    descriptor_enumerable : bool option;
+                    descriptor_configurable : bool option }
+
+(** val descriptor_value : descriptor -> value option **)
+
+let descriptor_value x = x.descriptor_value
+
+(** val descriptor_writable : descriptor -> bool option **)
+
+let descriptor_writable x = x.descriptor_writable
+
+(** val descriptor_get : descriptor -> value option **)
+
+let descriptor_get x = x.descriptor_get
+
+(** val descriptor_set : descriptor -> value option **)
+
+let descriptor_set x = x.descriptor_set
+
+(** val descriptor_enumerable : descriptor -> bool option **)
+
+let descriptor_enumerable x = x.descriptor_enumerable
+
+(** val descriptor_configurable : descriptor -> bool option **)
+
+let descriptor_configurable x = x.descriptor_configurable
+
+type full_descriptor =
+| Coq_full_descriptor_undef [@f]  (** Auto Generated Attributes **)
+| Coq_full_descriptor_some  [@f label0] of attributes (** Auto Generated Attributes **)
+
+type mutability =
+| Coq_mutability_uninitialized_immutable [@f]  (** Auto Generated Attributes **)
+| Coq_mutability_immutable [@f]  (** Auto Generated Attributes **)
+| Coq_mutability_nondeletable [@f]  (** Auto Generated Attributes **)
+| Coq_mutability_deletable [@f]  (** Auto Generated Attributes **)
+
+type decl_env_record = (char list, mutability * value) Heap.heap
+
+type provide_this_flag = bool
+
+type env_record =
+| Coq_env_record_decl  [@f label0] of decl_env_record (** Auto Generated Attributes **)
+| Coq_env_record_object  [@f label0, label1] of object_loc * provide_this_flag (** Auto Generated Attributes **)
+
+type env_loc = int
+
+(** val env_loc_global_env_record : env_loc **)
+
+let env_loc_global_env_record = 0
+
+type lexical_env = env_loc list
+
+type execution_ctx = { execution_ctx_lexical_env : lexical_env;
+                       execution_ctx_variable_env : lexical_env;
+                       execution_ctx_this_binding : value;
+                       execution_ctx_strict : strictness_flag }
+
+(** val execution_ctx_lexical_env : execution_ctx -> lexical_env **)
+
+let execution_ctx_lexical_env x = x.execution_ctx_lexical_env
+
+(** val execution_ctx_variable_env : execution_ctx -> lexical_env **)
+
+let execution_ctx_variable_env x = x.execution_ctx_variable_env
+
+(** val execution_ctx_this_binding : execution_ctx -> value **)
+
+let execution_ctx_this_binding x = x.execution_ctx_this_binding
+
+(** val execution_ctx_strict : execution_ctx -> strictness_flag **)
+
+let execution_ctx_strict x = x.execution_ctx_strict
+
+type prop_name = char list
+
+type ref_base_type =
+| Coq_ref_base_type_value  [@f label0] of value (** Auto Generated Attributes **)
+| Coq_ref_base_type_env_loc  [@f label0] of env_loc (** Auto Generated Attributes **)
+
+type ref = { ref_base : ref_base_type; ref_name : prop_name;
+             ref_strict : bool }
+
+(** val ref_base : ref -> ref_base_type **)
+
+let ref_base x = x.ref_base
+
+(** val ref_name : ref -> prop_name **)
+
+let ref_name x = x.ref_name
+
+(** val ref_strict : ref -> bool **)
+
+let ref_strict x = x.ref_strict
+
+type class_name = char list
+
+type object_properties_type = (prop_name, attributes) Heap.heap
+
+type coq_object = { object_proto_ : value; object_class_ : class_name;
+                    object_extensible_ : bool;
+                    object_prim_value_ : value option;
+                    object_properties_ : object_properties_type;
+                    object_get_ : builtin_get;
+                    object_get_own_prop_ : builtin_get_own_prop;
+                    object_get_prop_ : builtin_get_prop;
+                    object_put_ : builtin_put;
+                    object_can_put_ : builtin_can_put;
+                    object_has_prop_ : builtin_has_prop;
+                    object_delete_ : builtin_delete;
+                    object_default_value_ : builtin_default_value;
+                    object_define_own_prop_ : builtin_define_own_prop;
+                    object_construct_ : construct option;
+                    object_call_ : call option;
+                    object_has_instance_ : builtin_has_instance option;
+                    object_scope_ : lexical_env option;
+                    object_formal_parameters_ : char list list option;
+                    object_code_ : funcbody option;
+                    object_target_function_ : object_loc option;
+                    object_bound_this_ : value option;
+                    object_bound_args_ : value list option;
+                    object_parameter_map_ : object_loc option }
+
+(** val object_proto_ : coq_object -> value **)
+
+let object_proto_ x = x.object_proto_
+
+(** val object_class_ : coq_object -> class_name **)
+
+let object_class_ x = x.object_class_
+
+(** val object_extensible_ : coq_object -> bool **)
+
+let object_extensible_ x = x.object_extensible_
+
+(** val object_prim_value_ : coq_object -> value option **)
+
+let object_prim_value_ x = x.object_prim_value_
+
+(** val object_properties_ : coq_object -> object_properties_type **)
+
+let object_properties_ x = x.object_properties_
+
+(** val object_get_ : coq_object -> builtin_get **)
+
+let object_get_ x = x.object_get_
+
+(** val object_get_own_prop_ : coq_object -> builtin_get_own_prop **)
+
+let object_get_own_prop_ x = x.object_get_own_prop_
+
+(** val object_get_prop_ : coq_object -> builtin_get_prop **)
+
+let object_get_prop_ x = x.object_get_prop_
+
+(** val object_put_ : coq_object -> builtin_put **)
+
+let object_put_ x = x.object_put_
+
+(** val object_can_put_ : coq_object -> builtin_can_put **)
+
+let object_can_put_ x = x.object_can_put_
+
+(** val object_has_prop_ : coq_object -> builtin_has_prop **)
+
+let object_has_prop_ x = x.object_has_prop_
+
+(** val object_delete_ : coq_object -> builtin_delete **)
+
+let object_delete_ x = x.object_delete_
+
+(** val object_default_value_ : coq_object -> builtin_default_value **)
+
+let object_default_value_ x = x.object_default_value_
+
+(** val object_define_own_prop_ : coq_object -> builtin_define_own_prop **)
+
+let object_define_own_prop_ x = x.object_define_own_prop_
+
+(** val object_construct_ : coq_object -> construct option **)
+
+let object_construct_ x = x.object_construct_
+
+(** val object_call_ : coq_object -> call option **)
+
+let object_call_ x = x.object_call_
+
+(** val object_has_instance_ : coq_object -> builtin_has_instance option **)
+
+let object_has_instance_ x = x.object_has_instance_
+
+(** val object_scope_ : coq_object -> lexical_env option **)
+
+let object_scope_ x = x.object_scope_
+
+(** val object_formal_parameters_ : coq_object -> char list list option **)
+
+let object_formal_parameters_ x = x.object_formal_parameters_
+
+(** val object_code_ : coq_object -> funcbody option **)
+
+let object_code_ x = x.object_code_
+
+(** val object_target_function_ : coq_object -> object_loc option **)
+
+let object_target_function_ x = x.object_target_function_
+
+(** val object_bound_this_ : coq_object -> value option **)
+
+let object_bound_this_ x = x.object_bound_this_
+
+(** val object_bound_args_ : coq_object -> value list option **)
+
+let object_bound_args_ x = x.object_bound_args_
+
+(** val object_parameter_map_ : coq_object -> object_loc option **)
+
+let object_parameter_map_ x = x.object_parameter_map_
+
+type event =
+| Coq_delete_event  [@f label0, label1, label2] of object_loc * prop_name * object_loc option (** Auto Generated Attributes **)
+| Coq_mutateproto_event  [@f label0, label1, label2] of object_loc * (object_loc * prop_name) list (** Auto Generated Attributes **)
+   * (object_loc * prop_name) list
+| Coq_enumchange_event  [@f label0, label1] of object_loc * prop_name (** Auto Generated Attributes **)
+
+type state = { state_object_heap : (object_loc, coq_object) Heap.heap;
+               state_env_record_heap : (env_loc, env_record) Heap.heap;
+               state_fresh_locations : int stream;
+               state_event_list : event list }
+
+(** val state_object_heap : state -> (object_loc, coq_object) Heap.heap **)
+
+let state_object_heap x = x.state_object_heap
+
+(** val state_env_record_heap : state -> (env_loc, env_record) Heap.heap **)
+
+let state_env_record_heap x = x.state_env_record_heap
+
+type restype =
+| Coq_restype_normal [@f]  (** Auto Generated Attributes **)
+| Coq_restype_break [@f]  (** Auto Generated Attributes **)
+| Coq_restype_continue [@f]  (** Auto Generated Attributes **)
+| Coq_restype_return [@f]  (** Auto Generated Attributes **)
+| Coq_restype_throw [@f]  (** Auto Generated Attributes **)
+
+type resvalue =
+| Coq_resvalue_empty [@f]  (** Auto Generated Attributes **)
+| Coq_resvalue_value  [@f label0] of value (** Auto Generated Attributes **)
+| Coq_resvalue_ref  [@f label0] of ref (** Auto Generated Attributes **)
+
+type res = { res_type : restype; res_value : resvalue; res_label : label }
+
+(** val res_type : res -> restype **)
+
+let res_type x = x.res_type
+
+(** val res_value : res -> resvalue **)
+
+let res_value x = x.res_value
+
+(** val res_label : res -> label **)
+
+let res_label x = x.res_label
+
+(** val res_ref : ref -> res **)
+
+let res_ref r =
+  { res_type = Coq_restype_normal; res_value = (Coq_resvalue_ref r);
+    res_label = Coq_label_empty }
+
+(** val res_val : value -> res **)
+
+let res_val v =
+  { res_type = Coq_restype_normal; res_value = (Coq_resvalue_value v);
+    res_label = Coq_label_empty }
+
+(** val res_normal : resvalue -> res **)
+
+let res_normal rv =
+  { res_type = Coq_restype_normal; res_value = rv; res_label =
+    Coq_label_empty }
+
+(** val res_empty : res **)
+
+let res_empty =
+  { res_type = Coq_restype_normal; res_value = Coq_resvalue_empty;
+    res_label = Coq_label_empty }
+
+(** val res_break : label -> res **)
+
+let res_break labo =
+  { res_type = Coq_restype_break; res_value = Coq_resvalue_empty; res_label =
+    labo }
+
+(** val res_continue : label -> res **)
+
+let res_continue labo =
+  { res_type = Coq_restype_continue; res_value = Coq_resvalue_empty;
+    res_label = labo }
+
+(** val res_return : resvalue -> res **)
+
+let res_return v =
+  { res_type = Coq_restype_return; res_value = v; res_label =
+    Coq_label_empty }
+
+(** val res_throw : resvalue -> res **)
+
+let res_throw v =
+  { res_type = Coq_restype_throw; res_value = v; res_label =
+    Coq_label_empty }
+
+type out =
+| Coq_out_div [@f]  (** Auto Generated Attributes **)
+| Coq_out_ter  [@f label0, label1] of state * res (** Auto Generated Attributes **)
+
+(** val out_void : state -> out **)
+
+let out_void s =
+  Coq_out_ter (s, res_empty)
+
+type 't specret =
+| Coq_specret_val  [@f label0, label1] of state * 't (** Auto Generated Attributes **)
+| Coq_specret_out  [@f label0] of out (** Auto Generated Attributes **)
+
+type codetype =
+| Coq_codetype_func [@f]  (** Auto Generated Attributes **)
+| Coq_codetype_global [@f]  (** Auto Generated Attributes **)
+| Coq_codetype_eval [@f]  (** Auto Generated Attributes **)
+
diff --git a/generator/tests/jsref/JsSyntaxAux.ml b/generator/tests/jsref/JsSyntaxAux.ml
new file mode 100644
index 0000000..b23b5c9
--- /dev/null
+++ b/generator/tests/jsref/JsSyntaxAux.ml
@@ -0,0 +1,6842 @@
+open JsNumber
+open JsSyntax
+open LibList
+open LibNat
+open LibReflect
+open LibString
+
+(** val object_create :
+    value -> class_name -> bool -> object_properties_type -> coq_object **)
+
+let object_create vproto sclass bextens p =
+  { object_proto_ = vproto; object_class_ = sclass; object_extensible_ =
+    bextens; object_prim_value_ = None; object_properties_ = p; object_get_ =
+    Coq_builtin_get_default; object_get_own_prop_ =
+    Coq_builtin_get_own_prop_default; object_get_prop_ =
+    Coq_builtin_get_prop_default; object_put_ = Coq_builtin_put_default;
+    object_can_put_ = Coq_builtin_can_put_default; object_has_prop_ =
+    Coq_builtin_has_prop_default; object_delete_ =
+    Coq_builtin_delete_default; object_default_value_ =
+    Coq_builtin_default_value_default; object_define_own_prop_ =
+    Coq_builtin_define_own_prop_default; object_construct_ = None;
+    object_call_ = None; object_has_instance_ = None; object_scope_ = None;
+    object_formal_parameters_ = None; object_code_ = None;
+    object_target_function_ = None; object_bound_this_ = None;
+    object_bound_args_ = None; object_parameter_map_ = None }
+
+(** val object_set_proto : coq_object -> value -> coq_object **)
+
+let object_set_proto o v =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = v; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_set_class : coq_object -> class_name -> coq_object **)
+
+let object_set_class o s =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = s; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_set_extensible : coq_object -> bool -> coq_object **)
+
+let object_set_extensible o b =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = b;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_with_primitive_value : coq_object -> value -> coq_object **)
+
+let object_with_primitive_value o v =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = (Some v); object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_with_extension : coq_object -> bool -> coq_object **)
+
+let object_with_extension o b =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = b;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_with_properties :
+    coq_object -> object_properties_type -> coq_object **)
+
+let object_with_properties o properties =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = properties; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_with_get : coq_object -> builtin_get -> coq_object **)
+
+let object_with_get o g =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = g;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_with_get_own_property :
+    coq_object -> builtin_get_own_prop -> coq_object **)
+
+let object_with_get_own_property o gop =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = gop; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_with_invokation :
+    coq_object -> construct option -> call option -> builtin_has_instance
+    option -> coq_object **)
+
+let object_with_invokation o constr call0 has_instance =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = constr; object_call_ = call0; object_has_instance_ =
+  has_instance; object_scope_ = x18; object_formal_parameters_ = x19;
+  object_code_ = x20; object_target_function_ = x21; object_bound_this_ =
+  x22; object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_with_scope :
+    coq_object -> lexical_env option -> coq_object **)
+
+let object_with_scope o scope =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = scope; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_with_formal_params :
+    coq_object -> char list list option -> coq_object **)
+
+let object_with_formal_params o params =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = params; object_code_ =
+  x20; object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_with_details :
+    coq_object -> lexical_env option -> char list list option -> funcbody
+    option -> object_loc option -> value option -> value list option ->
+    object_loc option -> coq_object **)
+
+let object_with_details o scope params code target boundthis boundargs paramsmap =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = x14;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = scope; object_formal_parameters_ = params; object_code_ =
+  code; object_target_function_ = target; object_bound_this_ = boundthis;
+  object_bound_args_ = boundargs; object_parameter_map_ = paramsmap }
+
+(** val object_for_array :
+    coq_object -> builtin_define_own_prop -> coq_object **)
+
+let object_for_array o defineownproperty =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+  object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+  object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+  object_default_value_ = x13; object_define_own_prop_ = defineownproperty;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = x24 }
+
+(** val object_for_args_object :
+    coq_object -> object_loc -> builtin_get -> builtin_get_own_prop ->
+    builtin_define_own_prop -> builtin_delete -> coq_object **)
+
+let object_for_args_object o paramsmap get getownproperty defineownproperty delete =
+  let { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+    object_prim_value_ = x4; object_properties_ = x5; object_get_ = x6;
+    object_get_own_prop_ = x7; object_get_prop_ = x8; object_put_ = x9;
+    object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = x12;
+    object_default_value_ = x13; object_define_own_prop_ = x14;
+    object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+    object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+    object_target_function_ = x21; object_bound_this_ = x22;
+    object_bound_args_ = x23; object_parameter_map_ = x24 } = o
+  in
+  { object_proto_ = x1; object_class_ = x2; object_extensible_ = x3;
+  object_prim_value_ = x4; object_properties_ = x5; object_get_ = get;
+  object_get_own_prop_ = getownproperty; object_get_prop_ = x8; object_put_ =
+  x9; object_can_put_ = x10; object_has_prop_ = x11; object_delete_ = delete;
+  object_default_value_ = x13; object_define_own_prop_ = defineownproperty;
+  object_construct_ = x15; object_call_ = x16; object_has_instance_ = x17;
+  object_scope_ = x18; object_formal_parameters_ = x19; object_code_ = x20;
+  object_target_function_ = x21; object_bound_this_ = x22;
+  object_bound_args_ = x23; object_parameter_map_ = (Some paramsmap) }
+
+(** val mathop_compare : mathop -> mathop -> bool **)
+
+let mathop_compare m1 m2 =
+  let Coq_mathop_abs = m1 in let Coq_mathop_abs = m2 in true
+
+(** val mathop_comparable : mathop coq_Comparable **)
+
+let mathop_comparable x y =
+  mathop_compare x y
+
+(** val native_error_compare : native_error -> native_error -> bool **)
+
+let native_error_compare ne1 ne2 =
+  match ne1 with
+  | Coq_native_error_eval ->
+    (match ne2 with
+     | Coq_native_error_eval -> true
+     | Coq_native_error_range -> false
+     | Coq_native_error_ref -> false
+     | Coq_native_error_syntax -> false
+     | Coq_native_error_type -> false
+     | Coq_native_error_uri -> false)
+  | Coq_native_error_range ->
+    (match ne2 with
+     | Coq_native_error_eval -> false
+     | Coq_native_error_range -> true
+     | Coq_native_error_ref -> false
+     | Coq_native_error_syntax -> false
+     | Coq_native_error_type -> false
+     | Coq_native_error_uri -> false)
+  | Coq_native_error_ref ->
+    (match ne2 with
+     | Coq_native_error_eval -> false
+     | Coq_native_error_range -> false
+     | Coq_native_error_ref -> true
+     | Coq_native_error_syntax -> false
+     | Coq_native_error_type -> false
+     | Coq_native_error_uri -> false)
+  | Coq_native_error_syntax ->
+    (match ne2 with
+     | Coq_native_error_eval -> false
+     | Coq_native_error_range -> false
+     | Coq_native_error_ref -> false
+     | Coq_native_error_syntax -> true
+     | Coq_native_error_type -> false
+     | Coq_native_error_uri -> false)
+  | Coq_native_error_type ->
+    (match ne2 with
+     | Coq_native_error_eval -> false
+     | Coq_native_error_range -> false
+     | Coq_native_error_ref -> false
+     | Coq_native_error_syntax -> false
+     | Coq_native_error_type -> true
+     | Coq_native_error_uri -> false)
+  | Coq_native_error_uri ->
+    (match ne2 with
+     | Coq_native_error_eval -> false
+     | Coq_native_error_range -> false
+     | Coq_native_error_ref -> false
+     | Coq_native_error_syntax -> false
+     | Coq_native_error_type -> false
+     | Coq_native_error_uri -> true)
+
+(** val native_error_comparable : native_error coq_Comparable **)
+
+let native_error_comparable x y =
+  native_error_compare x y
+
+(** val prealloc_compare : prealloc -> prealloc -> bool **)
+
+let prealloc_compare bl1 bl2 =
+  match bl1 with
+  | Coq_prealloc_global ->
+    (match bl2 with
+     | Coq_prealloc_global -> true
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_global_eval ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> true
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_global_parse_int ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> true
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_global_parse_float ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> true
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_global_is_finite ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> true
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_global_is_nan ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> true
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_global_decode_uri ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> true
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_global_decode_uri_component ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> true
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_global_encode_uri ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> true
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_global_encode_uri_component ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> true
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> true
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_get_proto_of ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> true
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_get_own_prop_descriptor ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> true
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_get_own_prop_name ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> true
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_create ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> true
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_define_prop ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> true
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_define_props ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> true
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_seal ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> true
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_freeze ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> true
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_prevent_extensions ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> true
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_is_sealed ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> true
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_is_frozen ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> true
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_is_extensible ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> true
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_keys ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> true
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_keys_call ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> true
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_proto ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> true
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_proto_to_string ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> true
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_proto_value_of ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> true
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_proto_has_own_prop ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> true
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_proto_is_prototype_of ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> true
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_object_proto_prop_is_enumerable ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> true
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_function ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> true
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_function_proto ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> true
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_function_proto_to_string ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> true
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_function_proto_apply ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> true
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_function_proto_call ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> true
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_function_proto_bind ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> true
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_bool ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> true
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_bool_proto ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> true
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_bool_proto_to_string ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> true
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_bool_proto_value_of ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> true
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_number ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> true
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_number_proto ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> true
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_number_proto_to_string ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> true
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_number_proto_value_of ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> true
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_number_proto_to_fixed ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> true
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_number_proto_to_exponential ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> true
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_number_proto_to_precision ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> true
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_array ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> true
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_array_is_array ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> true
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_array_proto ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> true
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_array_proto_to_string ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> true
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_array_proto_join ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> true
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_array_proto_pop ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> true
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_array_proto_push ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> true
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_string ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> true
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_string_proto ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> true
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_string_proto_to_string ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> true
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_string_proto_value_of ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> true
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_string_proto_char_at ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> true
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_string_proto_char_code_at ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> true
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_math ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> true
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_mathop m1 ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m2 -> mathop_comparable m1 m2
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_date ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> true
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_regexp ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> true
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_error ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> true
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_error_proto ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> true
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_native_error ne1 ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error ne2 -> native_error_comparable ne1 ne2
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_native_error_proto ne1 ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto ne2 -> native_error_comparable ne1 ne2
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_error_proto_to_string ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> true
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_throw_type_error ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> true
+     | Coq_prealloc_json -> false)
+  | Coq_prealloc_json ->
+    (match bl2 with
+     | Coq_prealloc_global -> false
+     | Coq_prealloc_global_eval -> false
+     | Coq_prealloc_global_parse_int -> false
+     | Coq_prealloc_global_parse_float -> false
+     | Coq_prealloc_global_is_finite -> false
+     | Coq_prealloc_global_is_nan -> false
+     | Coq_prealloc_global_decode_uri -> false
+     | Coq_prealloc_global_decode_uri_component -> false
+     | Coq_prealloc_global_encode_uri -> false
+     | Coq_prealloc_global_encode_uri_component -> false
+     | Coq_prealloc_object -> false
+     | Coq_prealloc_object_get_proto_of -> false
+     | Coq_prealloc_object_get_own_prop_descriptor -> false
+     | Coq_prealloc_object_get_own_prop_name -> false
+     | Coq_prealloc_object_create -> false
+     | Coq_prealloc_object_define_prop -> false
+     | Coq_prealloc_object_define_props -> false
+     | Coq_prealloc_object_seal -> false
+     | Coq_prealloc_object_freeze -> false
+     | Coq_prealloc_object_prevent_extensions -> false
+     | Coq_prealloc_object_is_sealed -> false
+     | Coq_prealloc_object_is_frozen -> false
+     | Coq_prealloc_object_is_extensible -> false
+     | Coq_prealloc_object_keys -> false
+     | Coq_prealloc_object_keys_call -> false
+     | Coq_prealloc_object_proto -> false
+     | Coq_prealloc_object_proto_to_string -> false
+     | Coq_prealloc_object_proto_value_of -> false
+     | Coq_prealloc_object_proto_has_own_prop -> false
+     | Coq_prealloc_object_proto_is_prototype_of -> false
+     | Coq_prealloc_object_proto_prop_is_enumerable -> false
+     | Coq_prealloc_function -> false
+     | Coq_prealloc_function_proto -> false
+     | Coq_prealloc_function_proto_to_string -> false
+     | Coq_prealloc_function_proto_apply -> false
+     | Coq_prealloc_function_proto_call -> false
+     | Coq_prealloc_function_proto_bind -> false
+     | Coq_prealloc_bool -> false
+     | Coq_prealloc_bool_proto -> false
+     | Coq_prealloc_bool_proto_to_string -> false
+     | Coq_prealloc_bool_proto_value_of -> false
+     | Coq_prealloc_number -> false
+     | Coq_prealloc_number_proto -> false
+     | Coq_prealloc_number_proto_to_string -> false
+     | Coq_prealloc_number_proto_value_of -> false
+     | Coq_prealloc_number_proto_to_fixed -> false
+     | Coq_prealloc_number_proto_to_exponential -> false
+     | Coq_prealloc_number_proto_to_precision -> false
+     | Coq_prealloc_array -> false
+     | Coq_prealloc_array_is_array -> false
+     | Coq_prealloc_array_proto -> false
+     | Coq_prealloc_array_proto_to_string -> false
+     | Coq_prealloc_array_proto_join -> false
+     | Coq_prealloc_array_proto_pop -> false
+     | Coq_prealloc_array_proto_push -> false
+     | Coq_prealloc_string -> false
+     | Coq_prealloc_string_proto -> false
+     | Coq_prealloc_string_proto_to_string -> false
+     | Coq_prealloc_string_proto_value_of -> false
+     | Coq_prealloc_string_proto_char_at -> false
+     | Coq_prealloc_string_proto_char_code_at -> false
+     | Coq_prealloc_math -> false
+     | Coq_prealloc_mathop m -> false
+     | Coq_prealloc_date -> false
+     | Coq_prealloc_regexp -> false
+     | Coq_prealloc_error -> false
+     | Coq_prealloc_error_proto -> false
+     | Coq_prealloc_native_error n -> false
+     | Coq_prealloc_native_error_proto n -> false
+     | Coq_prealloc_error_proto_to_string -> false
+     | Coq_prealloc_throw_type_error -> false
+     | Coq_prealloc_json -> true)
+
+(** val prealloc_comparable : prealloc coq_Comparable **)
+
+let prealloc_comparable x y =
+  prealloc_compare x y
+
+(** val object_loc_compare : object_loc -> object_loc -> bool **)
+
+let object_loc_compare l1 l2 =
+  match l1 with
+  | Coq_object_loc_normal ln1 ->
+    (match l2 with
+     | Coq_object_loc_normal ln2 -> nat_comparable ln1 ln2
+     | Coq_object_loc_prealloc p -> false)
+  | Coq_object_loc_prealloc bl1 ->
+    (match l2 with
+     | Coq_object_loc_normal n -> false
+     | Coq_object_loc_prealloc bl2 -> prealloc_comparable bl1 bl2)
+
+(** val object_loc_comparable : object_loc coq_Comparable **)
+
+let object_loc_comparable x y =
+  object_loc_compare x y
+
+(** val prim_compare : prim -> prim -> bool **)
+
+let prim_compare w1 w2 =
+  match w1 with
+  | Coq_prim_undef ->
+    (match w2 with
+     | Coq_prim_undef -> true
+     | Coq_prim_null -> false
+     | Coq_prim_bool b -> false
+     | Coq_prim_number n -> false
+     | Coq_prim_string s -> false)
+  | Coq_prim_null ->
+    (match w2 with
+     | Coq_prim_undef -> false
+     | Coq_prim_null -> true
+     | Coq_prim_bool b -> false
+     | Coq_prim_number n -> false
+     | Coq_prim_string s -> false)
+  | Coq_prim_bool b1 ->
+    (match w2 with
+     | Coq_prim_undef -> false
+     | Coq_prim_null -> false
+     | Coq_prim_bool b2 -> bool_comparable b1 b2
+     | Coq_prim_number n -> false
+     | Coq_prim_string s -> false)
+  | Coq_prim_number n1 ->
+    (match w2 with
+     | Coq_prim_undef -> false
+     | Coq_prim_null -> false
+     | Coq_prim_bool b -> false
+     | Coq_prim_number n2 -> number_comparable n1 n2
+     | Coq_prim_string s -> false)
+  | Coq_prim_string s1 ->
+    (match w2 with
+     | Coq_prim_undef -> false
+     | Coq_prim_null -> false
+     | Coq_prim_bool b -> false
+     | Coq_prim_number n -> false
+     | Coq_prim_string s2 -> string_comparable s1 s2)
+
+(** val prim_comparable : prim coq_Comparable **)
+
+let prim_comparable x y =
+  prim_compare x y
+
+(** val value_compare : value -> value -> bool **)
+
+let value_compare v1 v2 =
+  match v1 with
+  | Coq_value_prim w1 ->
+    (match v2 with
+     | Coq_value_prim w2 -> prim_comparable w1 w2
+     | Coq_value_object o -> false)
+  | Coq_value_object l1 ->
+    (match v2 with
+     | Coq_value_prim p -> false
+     | Coq_value_object l2 -> object_loc_comparable l1 l2)
+
+(** val value_comparable : value coq_Comparable **)
+
+let value_comparable x y =
+  value_compare x y
+
+(** val mutability_compare : mutability -> mutability -> bool **)
+
+let mutability_compare m1 m2 =
+  match m1 with
+  | Coq_mutability_uninitialized_immutable ->
+    (match m2 with
+     | Coq_mutability_uninitialized_immutable -> true
+     | Coq_mutability_immutable -> false
+     | Coq_mutability_nondeletable -> false
+     | Coq_mutability_deletable -> false)
+  | Coq_mutability_immutable ->
+    (match m2 with
+     | Coq_mutability_uninitialized_immutable -> false
+     | Coq_mutability_immutable -> true
+     | Coq_mutability_nondeletable -> false
+     | Coq_mutability_deletable -> false)
+  | Coq_mutability_nondeletable ->
+    (match m2 with
+     | Coq_mutability_uninitialized_immutable -> false
+     | Coq_mutability_immutable -> false
+     | Coq_mutability_nondeletable -> true
+     | Coq_mutability_deletable -> false)
+  | Coq_mutability_deletable ->
+    (match m2 with
+     | Coq_mutability_uninitialized_immutable -> false
+     | Coq_mutability_immutable -> false
+     | Coq_mutability_nondeletable -> false
+     | Coq_mutability_deletable -> true)
+
+(** val mutability_comparable : mutability coq_Comparable **)
+
+let mutability_comparable x y =
+  mutability_compare x y
+
+(** val ref_base_type_compare : ref_base_type -> ref_base_type -> bool **)
+
+let ref_base_type_compare rb1 rb2 =
+  match rb1 with
+  | Coq_ref_base_type_value v1 ->
+    (match rb2 with
+     | Coq_ref_base_type_value v2 -> value_comparable v1 v2
+     | Coq_ref_base_type_env_loc e -> false)
+  | Coq_ref_base_type_env_loc l1 ->
+    (match rb2 with
+     | Coq_ref_base_type_value v -> false
+     | Coq_ref_base_type_env_loc l2 -> nat_comparable l1 l2)
+
+(** val ref_base_type_comparable : ref_base_type coq_Comparable **)
+
+let ref_base_type_comparable x y =
+  ref_base_type_compare x y
+
+(** val ref_compare : ref -> ref -> bool **)
+
+let ref_compare r1 r2 =
+  and_decidable (ref_base_type_comparable r1.ref_base r2.ref_base)
+    (and_decidable (string_comparable r1.ref_name r2.ref_name)
+      (bool_comparable r1.ref_strict r2.ref_strict))
+
+(** val ref_comparable : ref coq_Comparable **)
+
+let ref_comparable x y =
+  ref_compare x y
+
+(** val type_compare : coq_type -> coq_type -> bool **)
+
+let type_compare t1 t2 =
+  match t1 with
+  | Coq_type_undef ->
+    (match t2 with
+     | Coq_type_undef -> true
+     | Coq_type_null -> false
+     | Coq_type_bool -> false
+     | Coq_type_number -> false
+     | Coq_type_string -> false
+     | Coq_type_object -> false)
+  | Coq_type_null ->
+    (match t2 with
+     | Coq_type_undef -> false
+     | Coq_type_null -> true
+     | Coq_type_bool -> false
+     | Coq_type_number -> false
+     | Coq_type_string -> false
+     | Coq_type_object -> false)
+  | Coq_type_bool ->
+    (match t2 with
+     | Coq_type_undef -> false
+     | Coq_type_null -> false
+     | Coq_type_bool -> true
+     | Coq_type_number -> false
+     | Coq_type_string -> false
+     | Coq_type_object -> false)
+  | Coq_type_number ->
+    (match t2 with
+     | Coq_type_undef -> false
+     | Coq_type_null -> false
+     | Coq_type_bool -> false
+     | Coq_type_number -> true
+     | Coq_type_string -> false
+     | Coq_type_object -> false)
+  | Coq_type_string ->
+    (match t2 with
+     | Coq_type_undef -> false
+     | Coq_type_null -> false
+     | Coq_type_bool -> false
+     | Coq_type_number -> false
+     | Coq_type_string -> true
+     | Coq_type_object -> false)
+  | Coq_type_object ->
+    (match t2 with
+     | Coq_type_undef -> false
+     | Coq_type_null -> false
+     | Coq_type_bool -> false
+     | Coq_type_number -> false
+     | Coq_type_string -> false
+     | Coq_type_object -> true)
+
+(** val type_comparable : coq_type coq_Comparable **)
+
+let type_comparable x y =
+  type_compare x y
+
+(** val res_with_value : res -> resvalue -> res **)
+
+let res_with_value r rv =
+  let { res_type = rt; res_value = old_rv; res_label = labopt } = r in
+  { res_type = rt; res_value = rv; res_label = labopt }
+
+(** val resvalue_compare : resvalue -> resvalue -> bool **)
+
+let resvalue_compare rv1 rv2 =
+  match rv1 with
+  | Coq_resvalue_empty ->
+    (match rv2 with
+     | Coq_resvalue_empty -> true
+     | Coq_resvalue_value v -> false
+     | Coq_resvalue_ref r -> false)
+  | Coq_resvalue_value v1 ->
+    (match rv2 with
+     | Coq_resvalue_empty -> false
+     | Coq_resvalue_value v2 -> value_comparable v1 v2
+     | Coq_resvalue_ref r -> false)
+  | Coq_resvalue_ref r1 ->
+    (match rv2 with
+     | Coq_resvalue_empty -> false
+     | Coq_resvalue_value v -> false
+     | Coq_resvalue_ref r2 -> ref_comparable r1 r2)
+
+(** val resvalue_comparable : resvalue coq_Comparable **)
+
+let resvalue_comparable x y =
+  resvalue_compare x y
+
+(** val binary_op_compare : binary_op -> binary_op -> bool **)
+
+let rec binary_op_compare op1 op2 =
+  match op1 with
+  | Coq_binary_op_mult ->
+    (match op2 with
+     | Coq_binary_op_mult -> true
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_div ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> true
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_mod ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> true
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_add ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> true
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_sub ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> true
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_left_shift ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> true
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_right_shift ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> true
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_unsigned_right_shift ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> true
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_lt ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> true
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_gt ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> true
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_le ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> true
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_ge ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> true
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_instanceof ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> true
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_in ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> true
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_equal ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> true
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_disequal ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> true
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_strict_equal ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> true
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_strict_disequal ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> true
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_bitwise_and ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> true
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_bitwise_or ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> true
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_bitwise_xor ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> true
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_and ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> true
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_or ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> true
+     | Coq_binary_op_coma -> false)
+  | Coq_binary_op_coma ->
+    (match op2 with
+     | Coq_binary_op_mult -> false
+     | Coq_binary_op_div -> false
+     | Coq_binary_op_mod -> false
+     | Coq_binary_op_add -> false
+     | Coq_binary_op_sub -> false
+     | Coq_binary_op_left_shift -> false
+     | Coq_binary_op_right_shift -> false
+     | Coq_binary_op_unsigned_right_shift -> false
+     | Coq_binary_op_lt -> false
+     | Coq_binary_op_gt -> false
+     | Coq_binary_op_le -> false
+     | Coq_binary_op_ge -> false
+     | Coq_binary_op_instanceof -> false
+     | Coq_binary_op_in -> false
+     | Coq_binary_op_equal -> false
+     | Coq_binary_op_disequal -> false
+     | Coq_binary_op_strict_equal -> false
+     | Coq_binary_op_strict_disequal -> false
+     | Coq_binary_op_bitwise_and -> false
+     | Coq_binary_op_bitwise_or -> false
+     | Coq_binary_op_bitwise_xor -> false
+     | Coq_binary_op_and -> false
+     | Coq_binary_op_or -> false
+     | Coq_binary_op_coma -> true)
+
+(** val binary_op_comparable : binary_op coq_Comparable **)
+
+let binary_op_comparable x y =
+  binary_op_compare x y
+
+(** val prog_intro_strictness : prog -> strictness_flag **)
+
+let prog_intro_strictness = function
+| Coq_prog_intro (str, els) -> str
+
+(** val prog_elements : prog -> element list **)
+
+let prog_elements = function
+| Coq_prog_intro (str, els) -> els
+
+(** val funcbody_prog : funcbody -> prog **)
+
+let funcbody_prog = function
+| Coq_funcbody_intro (p, s) -> p
+
+(** val funcbody_is_strict : funcbody -> strictness_flag **)
+
+let funcbody_is_strict = function
+| Coq_funcbody_intro (p, s) ->
+  let Coq_prog_intro (b_strict, l) = p in b_strict
+
+(** val restype_compare : restype -> restype -> bool **)
+
+let restype_compare rt1 rt2 =
+  match rt1 with
+  | Coq_restype_normal ->
+    (match rt2 with
+     | Coq_restype_normal -> true
+     | Coq_restype_break -> false
+     | Coq_restype_continue -> false
+     | Coq_restype_return -> false
+     | Coq_restype_throw -> false)
+  | Coq_restype_break ->
+    (match rt2 with
+     | Coq_restype_normal -> false
+     | Coq_restype_break -> true
+     | Coq_restype_continue -> false
+     | Coq_restype_return -> false
+     | Coq_restype_throw -> false)
+  | Coq_restype_continue ->
+    (match rt2 with
+     | Coq_restype_normal -> false
+     | Coq_restype_break -> false
+     | Coq_restype_continue -> true
+     | Coq_restype_return -> false
+     | Coq_restype_throw -> false)
+  | Coq_restype_return ->
+    (match rt2 with
+     | Coq_restype_normal -> false
+     | Coq_restype_break -> false
+     | Coq_restype_continue -> false
+     | Coq_restype_return -> true
+     | Coq_restype_throw -> false)
+  | Coq_restype_throw ->
+    (match rt2 with
+     | Coq_restype_normal -> false
+     | Coq_restype_break -> false
+     | Coq_restype_continue -> false
+     | Coq_restype_return -> false
+     | Coq_restype_throw -> true)
+
+(** val restype_comparable : restype coq_Comparable **)
+
+let restype_comparable x y =
+  restype_compare x y
+
+(** val label_compare : label -> label -> bool **)
+
+let label_compare lab1 lab2 =
+  match lab1 with
+  | Coq_label_empty ->
+    (match lab2 with
+     | Coq_label_empty -> true
+     | Coq_label_string s -> false)
+  | Coq_label_string s1 ->
+    (match lab2 with
+     | Coq_label_empty -> false
+     | Coq_label_string s2 -> string_comparable s1 s2)
+
+(** val label_comparable : label coq_Comparable **)
+
+let label_comparable x y =
+  label_compare x y
+
+(** val label_set_empty : label_set **)
+
+let label_set_empty =
+  []
+
+(** val label_set_add : label -> label list -> label list **)
+
+let label_set_add lab labs =
+  lab :: labs
+
+(** val label_set_add_empty : label list -> label list **)
+
+let label_set_add_empty labs =
+  label_set_add Coq_label_empty labs
+
+(** val label_set_mem : label -> label list -> bool **)
+
+let label_set_mem lab labs =
+  coq_Mem_decidable label_comparable lab labs
+
+(** val attributes_data_with_value :
+    attributes_data -> value -> attributes_data **)
+
+let attributes_data_with_value ad v' =
+  let { attributes_data_value = v; attributes_data_writable = bw;
+    attributes_data_enumerable = be; attributes_data_configurable = bc } = ad
+  in
+  { attributes_data_value = v'; attributes_data_writable = bw;
+  attributes_data_enumerable = be; attributes_data_configurable = bc }
+
+(** val descriptor_with_value : descriptor -> value option -> descriptor **)
+
+let descriptor_with_value desc v' =
+  let { descriptor_value = v; descriptor_writable = bw; descriptor_get = vg;
+    descriptor_set = vs; descriptor_enumerable = be;
+    descriptor_configurable = bc } = desc
+  in
+  { descriptor_value = v'; descriptor_writable = bw; descriptor_get = vg;
+  descriptor_set = vs; descriptor_enumerable = be; descriptor_configurable =
+  bc }
+
+(** val descriptor_with_writable :
+    descriptor -> bool option -> descriptor **)
+
+let descriptor_with_writable desc bw' =
+  let { descriptor_value = v; descriptor_writable = bw; descriptor_get = vg;
+    descriptor_set = vs; descriptor_enumerable = be;
+    descriptor_configurable = bc } = desc
+  in
+  { descriptor_value = v; descriptor_writable = bw'; descriptor_get = vg;
+  descriptor_set = vs; descriptor_enumerable = be; descriptor_configurable =
+  bc }
+
+(** val descriptor_with_get : descriptor -> value option -> descriptor **)
+
+let descriptor_with_get desc vg' =
+  let { descriptor_value = v; descriptor_writable = bw; descriptor_get = vg;
+    descriptor_set = vs; descriptor_enumerable = be;
+    descriptor_configurable = bc } = desc
+  in
+  { descriptor_value = v; descriptor_writable = bw; descriptor_get = vg';
+  descriptor_set = vs; descriptor_enumerable = be; descriptor_configurable =
+  bc }
+
+(** val descriptor_with_set : descriptor -> value option -> descriptor **)
+
+let descriptor_with_set desc vs' =
+  let { descriptor_value = v; descriptor_writable = bw; descriptor_get = vg;
+    descriptor_set = vs; descriptor_enumerable = be;
+    descriptor_configurable = bc } = desc
+  in
+  { descriptor_value = v; descriptor_writable = bw; descriptor_get = vg;
+  descriptor_set = vs'; descriptor_enumerable = be; descriptor_configurable =
+  bc }
+
+(** val descriptor_with_enumerable :
+    descriptor -> bool option -> descriptor **)
+
+let descriptor_with_enumerable desc be' =
+  let { descriptor_value = v; descriptor_writable = bw; descriptor_get = vg;
+    descriptor_set = vs; descriptor_enumerable = be;
+    descriptor_configurable = bc } = desc
+  in
+  { descriptor_value = v; descriptor_writable = bw; descriptor_get = vg;
+  descriptor_set = vs; descriptor_enumerable = be'; descriptor_configurable =
+  bc }
+
+(** val descriptor_with_configurable :
+    descriptor -> bool option -> descriptor **)
+
+let descriptor_with_configurable desc bc' =
+  let { descriptor_value = v; descriptor_writable = bw; descriptor_get = vg;
+    descriptor_set = vs; descriptor_enumerable = be;
+    descriptor_configurable = bc } = desc
+  in
+  { descriptor_value = v; descriptor_writable = bw; descriptor_get = vg;
+  descriptor_set = vs; descriptor_enumerable = be; descriptor_configurable =
+  bc' }
+
+(** val codetype_compare : codetype -> codetype -> bool **)
+
+let codetype_compare ct1 ct2 =
+  match ct1 with
+  | Coq_codetype_func ->
+    (match ct2 with
+     | Coq_codetype_func -> true
+     | Coq_codetype_global -> false
+     | Coq_codetype_eval -> false)
+  | Coq_codetype_global ->
+    (match ct2 with
+     | Coq_codetype_func -> false
+     | Coq_codetype_global -> true
+     | Coq_codetype_eval -> false)
+  | Coq_codetype_eval ->
+    (match ct2 with
+     | Coq_codetype_func -> false
+     | Coq_codetype_global -> false
+     | Coq_codetype_eval -> true)
+
+(** val codetype_comparable : codetype coq_Comparable **)
+
+let codetype_comparable x y =
+  codetype_compare x y
+
diff --git a/generator/tests/jsref/JsSyntaxInfos.ml b/generator/tests/jsref/JsSyntaxInfos.ml
new file mode 100644
index 0000000..3c63dd6
--- /dev/null
+++ b/generator/tests/jsref/JsSyntaxInfos.ml
@@ -0,0 +1,121 @@
+open JsSyntax
+open JsSyntaxAux
+open LibBool
+open List0
+
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
+(** val add_infos_exp : strictness_flag -> expr -> expr **)
+
+let rec add_infos_exp str e =
+  let f = add_infos_exp str in
+  (match e with
+   | Coq_expr_this -> e
+   | Coq_expr_identifier s -> e
+   | Coq_expr_literal l -> e
+   | Coq_expr_object l -> e
+   | Coq_expr_array oes ->
+     Coq_expr_array
+       (map (fun oe ->
+         match oe with
+         | Some e0 -> Some (f e0)
+         | None -> None) oes)
+   | Coq_expr_function (so, ss, fb) ->
+     Coq_expr_function (so, ss, (add_infos_funcbody str fb))
+   | Coq_expr_access (e1, e2) -> Coq_expr_access ((f e1), (f e2))
+   | Coq_expr_member (e0, s) -> Coq_expr_member ((f e0), s)
+   | Coq_expr_new (e0, es) -> Coq_expr_new ((f e0), (map f es))
+   | Coq_expr_call (e0, es) -> Coq_expr_call ((f e0), (map f es))
+   | Coq_expr_unary_op (op, e0) -> Coq_expr_unary_op (op, (f e0))
+   | Coq_expr_binary_op (e1, op, e2) ->
+     Coq_expr_binary_op ((f e1), op, (f e2))
+   | Coq_expr_conditional (e1, e2, e3) ->
+     Coq_expr_conditional ((f e1), (f e2), (f e3))
+   | Coq_expr_assign (e1, op, e2) -> Coq_expr_assign ((f e1), op, (f e2)))
+
+(** val add_infos_funcbody : strictness_flag -> funcbody -> funcbody **)
+
+and add_infos_funcbody str = function
+| Coq_funcbody_intro (p, s) -> Coq_funcbody_intro ((add_infos_prog str p), s)
+
+(** val add_infos_stat : strictness_flag -> label_set -> stat -> stat **)
+
+and add_infos_stat str labs t =
+  let opt = fun _ f smth ->
+    match smth with
+    | Some smth0 -> Some (f smth0)
+    | None -> None
+  in
+  let f = add_infos_stat str label_set_empty in
+  let fo = opt __ f in
+  let fe = add_infos_exp str in
+  let feo = opt __ fe in
+  let fsb = add_infos_switchbody str in
+  (match t with
+   | Coq_stat_expr e -> Coq_stat_expr (fe e)
+   | Coq_stat_label (l, t0) ->
+     Coq_stat_label (l,
+       (add_infos_stat str (label_set_add (Coq_label_string l) labs) t0))
+   | Coq_stat_block ts -> Coq_stat_block (map f ts)
+   | Coq_stat_var_decl vars ->
+     Coq_stat_var_decl
+       (map (fun var -> let (s, eo) = var in (s, (feo eo))) vars)
+   | Coq_stat_if (e, t0, to0) -> Coq_stat_if ((fe e), (f t0), (fo to0))
+   | Coq_stat_do_while (l, t0, e) ->
+     Coq_stat_do_while ((label_set_add_empty labs), (f t0), (fe e))
+   | Coq_stat_while (l, e, t0) ->
+     Coq_stat_while ((label_set_add_empty labs), (fe e), (f t0))
+   | Coq_stat_with (e, t0) -> Coq_stat_with ((fe e), (f t0))
+   | Coq_stat_throw e -> Coq_stat_throw (fe e)
+   | Coq_stat_return eo -> Coq_stat_return (feo eo)
+   | Coq_stat_break lopt -> Coq_stat_break lopt
+   | Coq_stat_continue lopt -> Coq_stat_continue lopt
+   | Coq_stat_try (t0, catch, to0) ->
+     Coq_stat_try ((f t0),
+       (opt __ (fun c -> let (cs, t1) = c in (cs, (f t1))) catch), (fo to0))
+   | Coq_stat_for (l, eo1, eo2, eo3, t0) ->
+     Coq_stat_for ((label_set_add_empty labs), (feo eo1), (feo eo2),
+       (feo eo3), (f t0))
+   | Coq_stat_for_var (l, vars, eo2, eo3, t0) ->
+     Coq_stat_for_var ((label_set_add_empty labs),
+       (map (fun var -> let (s, eo) = var in (s, (feo eo))) vars), (feo eo2),
+       (feo eo3), (f t0))
+   | Coq_stat_for_in (l, e1, e2, t0) ->
+     Coq_stat_for_in ((label_set_add_empty labs), (fe e1), (fe e2), (f t0))
+   | Coq_stat_for_in_var (l, str0, eo, e, t0) ->
+     Coq_stat_for_in_var ((label_set_add_empty labs), str0, (feo eo), 
+       (fe e), (f t0))
+   | Coq_stat_debugger -> Coq_stat_debugger
+   | Coq_stat_switch (labs0, e, ts) ->
+     Coq_stat_switch ((label_set_add_empty labs0), (fe e), (fsb ts)))
+
+(** val add_infos_switchbody :
+    strictness_flag -> switchbody -> switchbody **)
+
+and add_infos_switchbody str ts =
+  let fe = add_infos_exp str in
+  let fs = add_infos_stat str label_set_empty in
+  let f = fun sc ->
+    let Coq_switchclause_intro (e, l) = sc in
+    Coq_switchclause_intro ((fe e), (map fs l))
+  in
+  (match ts with
+   | Coq_switchbody_nodefault l -> Coq_switchbody_nodefault (map f l)
+   | Coq_switchbody_withdefault (l1, s, l2) ->
+     Coq_switchbody_withdefault ((map f l1), (map fs s), (map f l2)))
+
+(** val add_infos_prog : strictness_flag -> prog -> prog **)
+
+and add_infos_prog str = function
+| Coq_prog_intro (str', els) ->
+  let str'' = coq_or str str' in
+  Coq_prog_intro (str'', (map (add_infos_element str'') els))
+
+(** val add_infos_element : strictness_flag -> element -> element **)
+
+and add_infos_element str = function
+| Coq_element_stat t ->
+  Coq_element_stat (add_infos_stat str label_set_empty t)
+| Coq_element_func_decl (s, ss, fb) ->
+  Coq_element_func_decl (s, ss, (add_infos_funcbody str fb))
+
diff --git a/generator/tests/jsref/LibBool.ml b/generator/tests/jsref/LibBool.ml
new file mode 100644
index 0000000..10493cd
--- /dev/null
+++ b/generator/tests/jsref/LibBool.ml
@@ -0,0 +1,16 @@
+(** val coq_and : bool -> bool -> bool **)
+
+let coq_and x y =
+  if x then if y then true else false else false
+
+(** val coq_or : bool -> bool -> bool **)
+
+let coq_or x y =
+  if x then true else if y then true else false
+
+(** val neg : bool -> bool **)
+
+let neg = function
+| true -> false
+| false -> true
+
diff --git a/generator/tests/jsref/LibFunc.ml b/generator/tests/jsref/LibFunc.ml
new file mode 100644
index 0000000..a19d1a7
--- /dev/null
+++ b/generator/tests/jsref/LibFunc.ml
@@ -0,0 +1,5 @@
+(** val id : 'a1 -> 'a1 **)
+
+let id x =
+  x
+
diff --git a/generator/tests/jsref/LibHeap.ml b/generator/tests/jsref/LibHeap.ml
new file mode 100644
index 0000000..7904a4d
--- /dev/null
+++ b/generator/tests/jsref/LibHeap.ml
@@ -0,0 +1,95 @@
+open Datatypes
+open LibBool
+open LibList
+open LibReflect
+
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
+module type HeapSpec = 
+ sig 
+  type ('x0, 'x) heap 
+  
+  val empty : ('a1, 'a2) heap
+  
+  val write : ('a1, 'a2) heap -> 'a1 -> 'a2 -> ('a1, 'a2) heap
+  
+  val to_list : ('a1, 'a2) heap -> ('a1 * 'a2) list
+  
+  val read : 'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> 'a2
+  
+  val read_option :
+    'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> 'a2 option
+  
+  val rem : 'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> ('a1, 'a2) heap
+  
+  val indom_decidable :
+    'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> coq_Decidable
+ end
+
+module HeapList = 
+ struct 
+  type ('k, 'v) heap = ('k * 'v) list
+  
+  (** val empty : ('a1, 'a2) heap **)
+  
+  let empty =
+    []
+  
+  (** val to_list : ('a1, 'a2) heap -> ('a1, 'a2) heap **)
+  
+  let to_list l =
+    l
+  
+  (** val assoc : 'a1 coq_Comparable -> 'a1 -> ('a1 * 'a2) list -> 'a2 **)
+  
+  let rec assoc h1 k = function
+  | [] -> (raise Not_found) __
+  | p :: l' -> let (x, v) = p in if h1 x k then v else assoc h1 k l'
+  
+  (** val read : 'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> 'a2 **)
+  
+  let read h l k =
+    assoc h k l
+  
+  (** val write : ('a1, 'a2) heap -> 'a1 -> 'a2 -> ('a1 * 'a2) list **)
+  
+  let write l k v =
+    (k, v) :: l
+  
+  (** val rem :
+      'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> ('a1 * 'a2) list **)
+  
+  let rem h1 l k =
+    filter (fun p -> if h1 (fst p) k then false else true) l
+  
+  (** val read_option :
+      'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> 'a2 option **)
+  
+  let read_option h =
+    let rec read_option0 l k =
+      match l with
+      | [] -> None
+      | p :: l' ->
+        let (x, v) = p in if h x k then Some v else read_option0 l' k
+    in read_option0
+  
+  (** val mem_assoc :
+      'a2 coq_Comparable -> 'a2 -> ('a2 * 'a1) list -> bool **)
+  
+  let rec mem_assoc h1 k = function
+  | [] -> false
+  | p :: l' -> let (x, y) = p in coq_or (h1 x k) (mem_assoc h1 k l')
+  
+  (** val indom_dec :
+      'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> bool **)
+  
+  let indom_dec h1 h k =
+    mem_assoc h1 k h
+  
+  (** val indom_decidable :
+      'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> coq_Decidable **)
+  
+  let indom_decidable h h0 k =
+    indom_dec h h0 k
+ end
+
diff --git a/generator/tests/jsref/LibInt.ml b/generator/tests/jsref/LibInt.ml
new file mode 100644
index 0000000..fae323b
--- /dev/null
+++ b/generator/tests/jsref/LibInt.ml
@@ -0,0 +1,39 @@
+open BinInt
+open Datatypes
+open LibReflect
+
+(** val my_Z_of_nat : int -> float **)
+
+let my_Z_of_nat =
+  Z.of_nat
+
+(** val comparison_compare : comparison -> comparison -> bool **)
+
+let comparison_compare c1 c2 =
+  match c1 with
+  | Eq ->
+    (match c2 with
+     | Eq -> true
+     | Lt -> false
+     | Gt -> false)
+  | Lt ->
+    (match c2 with
+     | Eq -> false
+     | Lt -> true
+     | Gt -> false)
+  | Gt ->
+    (match c2 with
+     | Eq -> false
+     | Lt -> false
+     | Gt -> true)
+
+(** val comparison_comparable : comparison coq_Comparable **)
+
+let comparison_comparable x y =
+  comparison_compare x y
+
+(** val int_comparable : float coq_Comparable **)
+
+let int_comparable x y =
+  comparison_comparable (Z.compare x y) Eq
+
diff --git a/generator/tests/jsref/LibList.ml b/generator/tests/jsref/LibList.ml
new file mode 100644
index 0000000..bbfb890
--- /dev/null
+++ b/generator/tests/jsref/LibList.ml
@@ -0,0 +1,95 @@
+open LibOperation
+open LibReflect
+open Peano
+
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
+(** val list_eq_nil_decidable : 'a1 list -> coq_Decidable **)
+
+let list_eq_nil_decidable = function
+| [] -> true
+| a :: l0 -> false
+
+(** val fold_right : ('a1 -> 'a2 -> 'a2) -> 'a2 -> 'a1 list -> 'a2 **)
+
+let fold_right f =
+  let rec fold_right0 f0 acc = function
+  | [] -> acc
+  | x :: l' -> f0 x (fold_right0 f0 acc l')
+  in fold_right0 f
+
+(** val fold_left : ('a1 -> 'a2 -> 'a2) -> 'a2 -> 'a1 list -> 'a2 **)
+
+let fold_left f =
+  let rec fold_left0 f0 acc = function
+  | [] -> acc
+  | x :: l' -> fold_left0 f0 (f0 x acc) l'
+  in fold_left0 f
+
+(** val map : ('a1 -> 'a2) -> 'a1 list -> 'a2 list **)
+
+let map f =
+  let () = () in fold_right (fun x acc -> (f x) :: acc) []
+
+(** val filter : 'a1 predb -> 'a1 list -> 'a1 list **)
+
+let filter f =
+  let () = () in fold_right (fun x acc -> if f x then x :: acc else acc) []
+
+(** val append : 'a1 list -> 'a1 list -> 'a1 list **)
+
+let append l1 l2 =
+  let () = () in fold_right (fun x acc -> x :: acc) l2 l1
+
+(** val concat : 'a1 list list -> 'a1 list **)
+
+let concat l =
+  (let () = () in fold_right append []) l
+
+(** val rev : 'a1 list -> 'a1 list **)
+
+let rev l =
+  (let () = () in fold_left (fun x acc -> x :: acc) []) l
+
+(** val length : 'a1 list -> int **)
+
+let length l =
+  (let () = () in fold_right (fun x acc -> plus (Pervasives.succ 0) acc) 0) l
+
+(** val take_drop_last : 'a1 list -> 'a1 list * 'a1 **)
+
+let take_drop_last l =
+  let rec take_drop_last0 = function
+  | [] -> (raise Not_found) __
+  | x :: l' ->
+    (match l' with
+     | [] -> ([], x)
+     | a :: l1 -> let (t, y) = take_drop_last0 l' in ((x :: t), y))
+  in take_drop_last0 l
+
+(** val nth_def : 'a1 -> int -> 'a1 list -> 'a1 **)
+
+let nth_def d =
+  let rec nth_def0 d0 n = function
+  | [] -> d0
+  | x :: l' ->
+    ((fun fO fS n -> if n=0 then fO () else fS (n-1))
+       (fun _ ->
+       x)
+       (fun n' ->
+       nth_def0 d0 n' l')
+       n)
+  in nth_def0 d
+
+(** val mem_decide : 'a1 coq_Comparable -> 'a1 -> 'a1 list -> bool **)
+
+let rec mem_decide h x = function
+| [] -> false
+| y :: l' -> if h x y then true else mem_decide h x l'
+
+(** val coq_Mem_decidable :
+    'a1 coq_Comparable -> 'a1 -> 'a1 list -> coq_Decidable **)
+
+let coq_Mem_decidable h x l =
+  mem_decide h x l
+
diff --git a/generator/tests/jsref/LibLogic.ml b/generator/tests/jsref/LibLogic.ml
new file mode 100644
index 0000000..bdfa92f
--- /dev/null
+++ b/generator/tests/jsref/LibLogic.ml
@@ -0,0 +1,3 @@
+type __ = Obj.t
+let __ = let rec f _ = Obj.repr f in Obj.repr f
+
diff --git a/generator/tests/jsref/LibNat.ml b/generator/tests/jsref/LibNat.ml
new file mode 100644
index 0000000..f1fe6af
--- /dev/null
+++ b/generator/tests/jsref/LibNat.ml
@@ -0,0 +1,27 @@
+open LibReflect
+
+(** val nat_compare : int -> int -> bool **)
+
+let rec nat_compare x y =
+  (fun fO fS n -> if n=0 then fO () else fS (n-1))
+    (fun _ ->
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      true)
+      (fun n ->
+      false)
+      y)
+    (fun x' ->
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      false)
+      (fun y' ->
+      nat_compare x' y')
+      y)
+    x
+
+(** val nat_comparable : int coq_Comparable **)
+
+let nat_comparable x y =
+  nat_compare x y
+
diff --git a/generator/tests/jsref/LibOperation.ml b/generator/tests/jsref/LibOperation.ml
new file mode 100644
index 0000000..999ca97
--- /dev/null
+++ b/generator/tests/jsref/LibOperation.ml
@@ -0,0 +1,2 @@
+type 'a predb = 'a -> bool
+
diff --git a/generator/tests/jsref/LibOption.ml b/generator/tests/jsref/LibOption.ml
new file mode 100644
index 0000000..01593ce
--- /dev/null
+++ b/generator/tests/jsref/LibOption.ml
@@ -0,0 +1,34 @@
+open LibReflect
+
+(** val option_compare :
+    'a1 coq_Comparable -> 'a1 option -> 'a1 option -> bool **)
+
+let option_compare h o1 o2 =
+  match o1 with
+  | Some v1 ->
+    (match o2 with
+     | Some v2 -> h v1 v2
+     | None -> false)
+  | None ->
+    (match o2 with
+     | Some a -> false
+     | None -> true)
+
+(** val option_comparable :
+    'a1 coq_Comparable -> 'a1 option coq_Comparable **)
+
+let option_comparable h x y =
+  option_compare h x y
+
+(** val unsome_default : 'a1 -> 'a1 option -> 'a1 **)
+
+let unsome_default d = function
+| Some x -> x
+| None -> d
+
+(** val map : ('a1 -> 'a2) -> 'a1 option -> 'a2 option **)
+
+let map f = function
+| Some x -> Some (f x)
+| None -> None
+
diff --git a/generator/tests/jsref/LibProd.ml b/generator/tests/jsref/LibProd.ml
new file mode 100644
index 0000000..7830d5d
--- /dev/null
+++ b/generator/tests/jsref/LibProd.ml
@@ -0,0 +1,15 @@
+open LibReflect
+
+(** val prod_compare :
+    'a1 coq_Comparable -> 'a2 coq_Comparable -> ('a1 * 'a2) -> ('a1 * 'a2) ->
+    bool **)
+
+let prod_compare h h0 x y =
+  let (x1, x2) = x in let (y1, y2) = y in and_decidable (h x1 y1) (h0 x2 y2)
+
+(** val prod_comparable :
+    'a1 coq_Comparable -> 'a2 coq_Comparable -> ('a1 * 'a2) coq_Comparable **)
+
+let prod_comparable cA cB x y =
+  prod_compare cA cB x y
+
diff --git a/generator/tests/jsref/LibReflect.ml b/generator/tests/jsref/LibReflect.ml
new file mode 100644
index 0000000..61b683d
--- /dev/null
+++ b/generator/tests/jsref/LibReflect.ml
@@ -0,0 +1,56 @@
+open Bool0
+open LibBool
+
+type coq_Decidable =
+  bool
+  (* singleton inductive, whose constructor was decidable_make *)
+
+(** val true_decidable : coq_Decidable **)
+
+let true_decidable =
+  true
+
+(** val false_decidable : coq_Decidable **)
+
+let false_decidable =
+  false
+
+(** val bool_decidable : bool -> coq_Decidable **)
+
+let bool_decidable b =
+  b
+
+(** val not_decidable : coq_Decidable -> coq_Decidable **)
+
+let not_decidable h =
+  neg h
+
+(** val or_decidable : coq_Decidable -> coq_Decidable -> coq_Decidable **)
+
+let or_decidable h h0 =
+  coq_or h h0
+
+(** val and_decidable : coq_Decidable -> coq_Decidable -> coq_Decidable **)
+
+let and_decidable h h0 =
+  coq_and h h0
+
+type 'a coq_Comparable =
+  'a -> 'a -> coq_Decidable
+  (* singleton inductive, whose constructor was make_comparable *)
+
+(** val comparable_of_dec : ('a1 -> 'a1 -> bool) -> 'a1 coq_Comparable **)
+
+let comparable_of_dec h x y =
+  if h x y then true else false
+
+(** val bool_comparable : bool coq_Comparable **)
+
+let bool_comparable x y =
+  eqb x y
+
+(** val prop_eq_decidable :
+    coq_Decidable -> coq_Decidable -> coq_Decidable **)
+
+let prop_eq_decidable = (=)
+
diff --git a/generator/tests/jsref/LibStream.ml b/generator/tests/jsref/LibStream.ml
new file mode 100644
index 0000000..bca633d
--- /dev/null
+++ b/generator/tests/jsref/LibStream.ml
@@ -0,0 +1,4 @@
+type 'a stream = 'a __stream Lazy.t
+and 'a __stream =
+| Coq_stream_intro  [@f label0, label1] of 'a * 'a stream (** Auto Generated Attributes **)
+
diff --git a/generator/tests/jsref/LibString.ml b/generator/tests/jsref/LibString.ml
new file mode 100644
index 0000000..d5f3b73
--- /dev/null
+++ b/generator/tests/jsref/LibString.ml
@@ -0,0 +1,8 @@
+open LibReflect
+open String0
+
+(** val string_comparable : char list coq_Comparable **)
+
+let string_comparable =
+  comparable_of_dec string_dec
+
diff --git a/generator/tests/jsref/LibTactics.ml b/generator/tests/jsref/LibTactics.ml
new file mode 100644
index 0000000..9baa5d5
--- /dev/null
+++ b/generator/tests/jsref/LibTactics.ml
@@ -0,0 +1,5 @@
+(** val let_binding : 'a1 -> ('a1 -> 'a2) -> 'a2 **)
+
+let let_binding v k =
+  k v
+
diff --git a/generator/tests/jsref/List0.ml b/generator/tests/jsref/List0.ml
new file mode 100644
index 0000000..2dfb950
--- /dev/null
+++ b/generator/tests/jsref/List0.ml
@@ -0,0 +1,20 @@
+(** val hd : 'a1 -> 'a1 list -> 'a1 **)
+
+let hd default = function
+| [] -> default
+| x :: l0 -> x
+
+(** val tl : 'a1 list -> 'a1 list **)
+
+let tl = function
+| [] -> []
+| a :: m -> m
+
+(** val map : ('a1 -> 'a2) -> 'a1 list -> 'a2 list **)
+
+let map f =
+  let rec map0 = function
+  | [] -> []
+  | a :: t -> (f a) :: (map0 t)
+  in map0
+
diff --git a/generator/tests/jsref/Peano.ml b/generator/tests/jsref/Peano.ml
new file mode 100644
index 0000000..5f155b5
--- /dev/null
+++ b/generator/tests/jsref/Peano.ml
@@ -0,0 +1,14 @@
+(** val plus : int -> int -> int **)
+
+let rec plus = (+)
+
+(** val nat_iter : int -> ('a1 -> 'a1) -> 'a1 -> 'a1 **)
+
+let rec nat_iter n f x =
+  (fun fO fS n -> if n=0 then fO () else fS (n-1))
+    (fun _ ->
+    x)
+    (fun n' ->
+    f (nat_iter n' f x))
+    n
+
diff --git a/generator/tests/jsref/Shared.ml b/generator/tests/jsref/Shared.ml
new file mode 100644
index 0000000..fccb1cc
--- /dev/null
+++ b/generator/tests/jsref/Shared.ml
@@ -0,0 +1,87 @@
+open BinInt
+open Datatypes
+open LibHeap
+open LibReflect
+open String0
+
+(** val option_case : 'a2 -> ('a1 -> 'a2) -> 'a1 option -> 'a2 **)
+
+let option_case d f = function
+| Some x -> f x
+| None -> d
+
+(** val int_of_char : char -> float **)
+
+let int_of_char = (fun c -> float_of_int (int_of_char c))
+
+(** val ascii_comparable : char coq_Comparable **)
+
+let ascii_comparable = (=)
+
+(** val string_sub : char list -> float -> float -> char list **)
+
+let string_sub s n l =
+  substring (Z.abs_nat n) (Z.abs_nat l) s
+
+(** val lt_int_decidable : float -> float -> coq_Decidable **)
+
+let lt_int_decidable = (<)
+
+(** val le_int_decidable : float -> float -> coq_Decidable **)
+
+let le_int_decidable = (<=)
+
+(** val ge_nat_decidable : int -> int -> coq_Decidable **)
+
+let ge_nat_decidable = (>=)
+
+type 'a coq_Pickable_option =
+  'a option
+  (* singleton inductive, whose constructor was pickable_option_make *)
+
+module HeapGen = 
+ functor (Heap:HeapSpec) ->
+ struct 
+  type ('k, 'v) heap = int * ('k, 'v) Heap.heap
+  
+  (** val empty : ('a1, 'a2) heap **)
+  
+  let empty =
+    (0, Heap.empty)
+  
+  (** val to_list : ('a1, 'a2) heap -> ('a1 * 'a2) list **)
+  
+  let to_list h =
+    Heap.to_list (snd h)
+  
+  (** val read : 'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> 'a2 **)
+  
+  let read h h0 =
+    Heap.read h (snd h0)
+  
+  (** val write :
+      ('a1, 'a2) heap -> 'a1 -> 'a2 -> int * ('a1, 'a2) Heap.heap **)
+  
+  let write h k v =
+    let (id, h0) = h in ((Pervasives.succ id), (Heap.write (snd h) k v))
+  
+  (** val rem :
+      'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> int * ('a1, 'a2)
+      Heap.heap **)
+  
+  let rem h h0 k =
+    let (id, h1) = h0 in ((Pervasives.succ id), (Heap.rem h (snd h0) k))
+  
+  (** val read_option :
+      'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> 'a2 option **)
+  
+  let read_option h h0 =
+    Heap.read_option h (snd h0)
+  
+  (** val indom_decidable :
+      'a1 coq_Comparable -> ('a1, 'a2) heap -> 'a1 -> coq_Decidable **)
+  
+  let indom_decidable h1 = function
+  | (n, h0) -> Heap.indom_decidable h1 (snd (n, h0))
+ end
+
diff --git a/generator/tests/jsref/Specif.ml b/generator/tests/jsref/Specif.ml
new file mode 100644
index 0000000..7481ce4
--- /dev/null
+++ b/generator/tests/jsref/Specif.ml
@@ -0,0 +1,4 @@
+type 'a coq_sig =
+  'a
+  (* singleton inductive, whose constructor was exist *)
+
diff --git a/generator/tests/jsref/String0.ml b/generator/tests/jsref/String0.ml
new file mode 100644
index 0000000..4b7efde
--- /dev/null
+++ b/generator/tests/jsref/String0.ml
@@ -0,0 +1,48 @@
+(** val string_dec : char list -> char list -> bool **)
+
+let string_dec s1 s2 =
+  let rec f = function
+  | [] ->
+    (fun s0 ->
+      match s0 with
+      | [] -> true
+      | a::s3 -> false)
+  | a::s0 ->
+    (fun s3 ->
+      match s3 with
+      | [] -> false
+      | a0::s4 -> if (=) a a0 then if f s0 s4 then true else false else false)
+  in f s1 s2
+
+(** val append : char list -> char list -> char list **)
+
+let rec append s1 s2 =
+  match s1 with
+  | [] -> s2
+  | c::s1' -> c::(append s1' s2)
+
+(** val length : char list -> int **)
+
+let rec length = function
+| [] -> 0
+| c::s' -> Pervasives.succ (length s')
+
+(** val substring : int -> int -> char list -> char list **)
+
+let rec substring n m s =
+  (fun fO fS n -> if n=0 then fO () else fS (n-1))
+    (fun _ ->
+    (fun fO fS n -> if n=0 then fO () else fS (n-1))
+      (fun _ ->
+      [])
+      (fun m' ->
+      match s with
+      | [] -> s
+      | c::s' -> c::(substring 0 m' s'))
+      m)
+    (fun n' ->
+    match s with
+    | [] -> s
+    | c::s' -> substring n' m s')
+    n
+
-- 
GitLab